diff options
Diffstat (limited to 'Python')
49 files changed, 13583 insertions, 8936 deletions
diff --git a/Python/Python-ast.c b/Python/Python-ast.c index 44fdafc50a..edfcbad134 100644 --- a/Python/Python-ast.c +++ b/Python/Python-ast.c @@ -45,17 +45,21 @@ static char *FunctionDef_fields[]={ "decorator_list", "returns", }; +static PyTypeObject *AsyncFunctionDef_type; +static char *AsyncFunctionDef_fields[]={ + "name", + "args", + "body", + "decorator_list", + "returns", +}; 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", }; @@ -91,6 +95,13 @@ static char *For_fields[]={ "body", "orelse", }; +static PyTypeObject *AsyncFor_type; +static char *AsyncFor_fields[]={ + "target", + "iter", + "body", + "orelse", +}; static PyTypeObject *While_type; _Py_IDENTIFIER(test); static char *While_fields[]={ @@ -110,6 +121,11 @@ static char *With_fields[]={ "items", "body", }; +static PyTypeObject *AsyncWith_type; +static char *AsyncWith_fields[]={ + "items", + "body", +}; static PyTypeObject *Raise_type; _Py_IDENTIFIER(exc); _Py_IDENTIFIER(cause); @@ -232,6 +248,10 @@ static char *GeneratorExp_fields[]={ "elt", "generators", }; +static PyTypeObject *Await_type; +static char *Await_fields[]={ + "value", +}; static PyTypeObject *Yield_type; static char *Yield_fields[]={ "value", @@ -254,8 +274,6 @@ static char *Call_fields[]={ "func", "args", "keywords", - "starargs", - "kwargs", }; static PyTypeObject *Num_type; _Py_IDENTIFIER(n); @@ -349,13 +367,14 @@ static PyTypeObject *And_type; static PyTypeObject *Or_type; static PyTypeObject *operator_type; static PyObject *Add_singleton, *Sub_singleton, *Mult_singleton, -*Div_singleton, *Mod_singleton, *Pow_singleton, *LShift_singleton, -*RShift_singleton, *BitOr_singleton, *BitXor_singleton, *BitAnd_singleton, -*FloorDiv_singleton; +*MatMult_singleton, *Div_singleton, *Mod_singleton, *Pow_singleton, +*LShift_singleton, *RShift_singleton, *BitOr_singleton, *BitXor_singleton, +*BitAnd_singleton, *FloorDiv_singleton; static PyObject* ast2obj_operator(operator_ty); static PyTypeObject *Add_type; static PyTypeObject *Sub_type; static PyTypeObject *Mult_type; +static PyTypeObject *MatMult_type; static PyTypeObject *Div_type; static PyTypeObject *Mod_type; static PyTypeObject *Pow_type; @@ -811,7 +830,10 @@ static int init_types(void) 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); + AsyncFunctionDef_type = make_type("AsyncFunctionDef", stmt_type, + AsyncFunctionDef_fields, 5); + if (!AsyncFunctionDef_type) return 0; + 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; @@ -823,12 +845,16 @@ static int init_types(void) if (!AugAssign_type) return 0; For_type = make_type("For", stmt_type, For_fields, 4); if (!For_type) return 0; + AsyncFor_type = make_type("AsyncFor", stmt_type, AsyncFor_fields, 4); + if (!AsyncFor_type) return 0; While_type = make_type("While", stmt_type, While_fields, 3); if (!While_type) return 0; If_type = make_type("If", stmt_type, If_fields, 3); if (!If_type) return 0; With_type = make_type("With", stmt_type, With_fields, 2); if (!With_type) return 0; + AsyncWith_type = make_type("AsyncWith", stmt_type, AsyncWith_fields, 2); + if (!AsyncWith_type) return 0; Raise_type = make_type("Raise", stmt_type, Raise_fields, 2); if (!Raise_type) return 0; Try_type = make_type("Try", stmt_type, Try_fields, 4); @@ -877,13 +903,15 @@ static int init_types(void) GeneratorExp_type = make_type("GeneratorExp", expr_type, GeneratorExp_fields, 2); if (!GeneratorExp_type) return 0; + Await_type = make_type("Await", expr_type, Await_fields, 1); + if (!Await_type) return 0; Yield_type = make_type("Yield", expr_type, Yield_fields, 1); if (!Yield_type) return 0; YieldFrom_type = make_type("YieldFrom", expr_type, YieldFrom_fields, 1); 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; @@ -970,6 +998,10 @@ static int init_types(void) if (!Mult_type) return 0; Mult_singleton = PyType_GenericNew(Mult_type, NULL, NULL); if (!Mult_singleton) return 0; + MatMult_type = make_type("MatMult", operator_type, NULL, 0); + if (!MatMult_type) return 0; + MatMult_singleton = PyType_GenericNew(MatMult_type, NULL, NULL); + if (!MatMult_singleton) return 0; Div_type = make_type("Div", operator_type, NULL, 0); if (!Div_type) return 0; Div_singleton = PyType_GenericNew(Div_type, NULL, NULL); @@ -1202,9 +1234,39 @@ FunctionDef(identifier name, arguments_ty args, asdl_seq * body, asdl_seq * } 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) +AsyncFunctionDef(identifier name, arguments_ty args, asdl_seq * body, asdl_seq + * decorator_list, expr_ty returns, int lineno, int col_offset, + PyArena *arena) +{ + stmt_ty p; + if (!name) { + PyErr_SetString(PyExc_ValueError, + "field name is required for AsyncFunctionDef"); + return NULL; + } + if (!args) { + PyErr_SetString(PyExc_ValueError, + "field args is required for AsyncFunctionDef"); + return NULL; + } + p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); + if (!p) + return NULL; + p->kind = AsyncFunctionDef_kind; + p->v.AsyncFunctionDef.name = name; + p->v.AsyncFunctionDef.args = args; + p->v.AsyncFunctionDef.body = body; + p->v.AsyncFunctionDef.decorator_list = decorator_list; + p->v.AsyncFunctionDef.returns = returns; + p->lineno = lineno; + p->col_offset = col_offset; + return p; +} + +stmt_ty +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) { @@ -1219,8 +1281,6 @@ ClassDef(identifier name, asdl_seq * bases, asdl_seq * keywords, expr_ty 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; @@ -1338,6 +1398,34 @@ For(expr_ty target, expr_ty iter, asdl_seq * body, asdl_seq * orelse, int } stmt_ty +AsyncFor(expr_ty target, expr_ty iter, asdl_seq * body, asdl_seq * orelse, int + lineno, int col_offset, PyArena *arena) +{ + stmt_ty p; + if (!target) { + PyErr_SetString(PyExc_ValueError, + "field target is required for AsyncFor"); + return NULL; + } + if (!iter) { + PyErr_SetString(PyExc_ValueError, + "field iter is required for AsyncFor"); + return NULL; + } + p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); + if (!p) + return NULL; + p->kind = AsyncFor_kind; + p->v.AsyncFor.target = target; + p->v.AsyncFor.iter = iter; + p->v.AsyncFor.body = body; + p->v.AsyncFor.orelse = orelse; + p->lineno = lineno; + p->col_offset = col_offset; + return p; +} + +stmt_ty While(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno, int col_offset, PyArena *arena) { @@ -1398,6 +1486,22 @@ With(asdl_seq * items, asdl_seq * body, int lineno, int col_offset, PyArena } stmt_ty +AsyncWith(asdl_seq * items, asdl_seq * body, int lineno, int col_offset, + PyArena *arena) +{ + stmt_ty p; + p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p)); + if (!p) + return NULL; + p->kind = AsyncWith_kind; + p->v.AsyncWith.items = items; + p->v.AsyncWith.body = body; + p->lineno = lineno; + p->col_offset = col_offset; + return p; +} + +stmt_ty Raise(expr_ty exc, expr_ty cause, int lineno, int col_offset, PyArena *arena) { stmt_ty p; @@ -1825,6 +1929,25 @@ GeneratorExp(expr_ty elt, asdl_seq * generators, int lineno, int col_offset, } expr_ty +Await(expr_ty value, int lineno, int col_offset, PyArena *arena) +{ + expr_ty p; + if (!value) { + PyErr_SetString(PyExc_ValueError, + "field value is required for Await"); + return NULL; + } + p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); + if (!p) + return NULL; + p->kind = Await_kind; + p->v.Await.value = value; + p->lineno = lineno; + p->col_offset = col_offset; + return p; +} + +expr_ty Yield(expr_ty value, int lineno, int col_offset, PyArena *arena) { expr_ty p; @@ -1880,8 +2003,8 @@ Compare(expr_ty left, asdl_int_seq * ops, asdl_seq * comparators, int lineno, } 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) { @@ -1896,8 +2019,6 @@ Call(expr_ty func, asdl_seq * args, asdl_seq * keywords, expr_ty starargs, 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; @@ -2251,7 +2372,8 @@ arguments(asdl_seq * args, arg_ty vararg, asdl_seq * kwonlyargs, asdl_seq * } arg_ty -arg(identifier arg, expr_ty annotation, PyArena *arena) +arg(identifier arg, expr_ty annotation, int lineno, int col_offset, PyArena + *arena) { arg_ty p; if (!arg) { @@ -2264,6 +2386,8 @@ arg(identifier arg, expr_ty annotation, PyArena *arena) return NULL; p->arg = arg; p->annotation = annotation; + p->lineno = lineno; + p->col_offset = col_offset; return p; } @@ -2271,11 +2395,6 @@ keyword_ty 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"); @@ -2419,6 +2538,36 @@ ast2obj_stmt(void* _o) goto failed; Py_DECREF(value); break; + case AsyncFunctionDef_kind: + result = PyType_GenericNew(AsyncFunctionDef_type, NULL, NULL); + if (!result) goto failed; + value = ast2obj_identifier(o->v.AsyncFunctionDef.name); + if (!value) goto failed; + if (_PyObject_SetAttrId(result, &PyId_name, value) == -1) + goto failed; + Py_DECREF(value); + value = ast2obj_arguments(o->v.AsyncFunctionDef.args); + if (!value) goto failed; + if (_PyObject_SetAttrId(result, &PyId_args, value) == -1) + goto failed; + Py_DECREF(value); + value = ast2obj_list(o->v.AsyncFunctionDef.body, ast2obj_stmt); + if (!value) goto failed; + if (_PyObject_SetAttrId(result, &PyId_body, value) == -1) + goto failed; + Py_DECREF(value); + value = ast2obj_list(o->v.AsyncFunctionDef.decorator_list, + ast2obj_expr); + if (!value) goto failed; + if (_PyObject_SetAttrId(result, &PyId_decorator_list, value) == -1) + goto failed; + Py_DECREF(value); + value = ast2obj_expr(o->v.AsyncFunctionDef.returns); + if (!value) goto failed; + if (_PyObject_SetAttrId(result, &PyId_returns, value) == -1) + goto failed; + Py_DECREF(value); + break; case ClassDef_kind: result = PyType_GenericNew(ClassDef_type, NULL, NULL); if (!result) goto failed; @@ -2437,16 +2586,6 @@ ast2obj_stmt(void* _o) 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) @@ -2533,6 +2672,30 @@ ast2obj_stmt(void* _o) goto failed; Py_DECREF(value); break; + case AsyncFor_kind: + result = PyType_GenericNew(AsyncFor_type, NULL, NULL); + if (!result) goto failed; + value = ast2obj_expr(o->v.AsyncFor.target); + if (!value) goto failed; + if (_PyObject_SetAttrId(result, &PyId_target, value) == -1) + goto failed; + Py_DECREF(value); + value = ast2obj_expr(o->v.AsyncFor.iter); + if (!value) goto failed; + if (_PyObject_SetAttrId(result, &PyId_iter, value) == -1) + goto failed; + Py_DECREF(value); + value = ast2obj_list(o->v.AsyncFor.body, ast2obj_stmt); + if (!value) goto failed; + if (_PyObject_SetAttrId(result, &PyId_body, value) == -1) + goto failed; + Py_DECREF(value); + value = ast2obj_list(o->v.AsyncFor.orelse, ast2obj_stmt); + if (!value) goto failed; + if (_PyObject_SetAttrId(result, &PyId_orelse, value) == -1) + goto failed; + Py_DECREF(value); + break; case While_kind: result = PyType_GenericNew(While_type, NULL, NULL); if (!result) goto failed; @@ -2585,6 +2748,20 @@ ast2obj_stmt(void* _o) goto failed; Py_DECREF(value); break; + case AsyncWith_kind: + result = PyType_GenericNew(AsyncWith_type, NULL, NULL); + if (!result) goto failed; + value = ast2obj_list(o->v.AsyncWith.items, ast2obj_withitem); + if (!value) goto failed; + if (_PyObject_SetAttrId(result, &PyId_items, value) == -1) + goto failed; + Py_DECREF(value); + value = ast2obj_list(o->v.AsyncWith.body, ast2obj_stmt); + if (!value) goto failed; + if (_PyObject_SetAttrId(result, &PyId_body, value) == -1) + goto failed; + Py_DECREF(value); + break; case Raise_kind: result = PyType_GenericNew(Raise_type, NULL, NULL); if (!result) goto failed; @@ -2898,6 +3075,15 @@ ast2obj_expr(void* _o) goto failed; Py_DECREF(value); break; + case Await_kind: + result = PyType_GenericNew(Await_type, NULL, NULL); + if (!result) goto failed; + value = ast2obj_expr(o->v.Await.value); + if (!value) goto failed; + if (_PyObject_SetAttrId(result, &PyId_value, value) == -1) + goto failed; + Py_DECREF(value); + break; case Yield_kind: result = PyType_GenericNew(Yield_type, NULL, NULL); if (!result) goto failed; @@ -2959,16 +3145,6 @@ ast2obj_expr(void* _o) 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); @@ -3232,6 +3408,9 @@ PyObject* ast2obj_operator(operator_ty o) case Mult: Py_INCREF(Mult_singleton); return Mult_singleton; + case MatMult: + Py_INCREF(MatMult_singleton); + return MatMult_singleton; case Div: Py_INCREF(Div_singleton); return Div_singleton; @@ -3859,6 +4038,102 @@ obj2ast_stmt(PyObject* obj, stmt_ty* out, PyArena* arena) if (*out == NULL) goto failed; return 0; } + isinstance = PyObject_IsInstance(obj, (PyObject*)AsyncFunctionDef_type); + if (isinstance == -1) { + return 1; + } + if (isinstance) { + identifier name; + arguments_ty args; + asdl_seq* body; + asdl_seq* decorator_list; + expr_ty returns; + + if (_PyObject_HasAttrId(obj, &PyId_name)) { + int res; + tmp = _PyObject_GetAttrId(obj, &PyId_name); + if (tmp == NULL) goto failed; + res = obj2ast_identifier(tmp, &name, arena); + if (res != 0) goto failed; + Py_CLEAR(tmp); + } else { + PyErr_SetString(PyExc_TypeError, "required field \"name\" missing from AsyncFunctionDef"); + return 1; + } + if (_PyObject_HasAttrId(obj, &PyId_args)) { + int res; + tmp = _PyObject_GetAttrId(obj, &PyId_args); + if (tmp == NULL) goto failed; + res = obj2ast_arguments(tmp, &args, arena); + if (res != 0) goto failed; + Py_CLEAR(tmp); + } else { + PyErr_SetString(PyExc_TypeError, "required field \"args\" missing from AsyncFunctionDef"); + return 1; + } + if (_PyObject_HasAttrId(obj, &PyId_body)) { + int res; + Py_ssize_t len; + Py_ssize_t i; + tmp = _PyObject_GetAttrId(obj, &PyId_body); + if (tmp == NULL) goto failed; + if (!PyList_Check(tmp)) { + PyErr_Format(PyExc_TypeError, "AsyncFunctionDef field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name); + goto failed; + } + len = PyList_GET_SIZE(tmp); + body = _Py_asdl_seq_new(len, arena); + if (body == NULL) goto failed; + for (i = 0; i < len; i++) { + stmt_ty value; + res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena); + if (res != 0) goto failed; + asdl_seq_SET(body, i, value); + } + Py_CLEAR(tmp); + } else { + PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from AsyncFunctionDef"); + return 1; + } + if (_PyObject_HasAttrId(obj, &PyId_decorator_list)) { + int res; + Py_ssize_t len; + Py_ssize_t i; + tmp = _PyObject_GetAttrId(obj, &PyId_decorator_list); + if (tmp == NULL) goto failed; + if (!PyList_Check(tmp)) { + PyErr_Format(PyExc_TypeError, "AsyncFunctionDef field \"decorator_list\" must be a list, not a %.200s", tmp->ob_type->tp_name); + goto failed; + } + len = PyList_GET_SIZE(tmp); + decorator_list = _Py_asdl_seq_new(len, arena); + if (decorator_list == NULL) goto failed; + for (i = 0; i < len; i++) { + expr_ty value; + res = obj2ast_expr(PyList_GET_ITEM(tmp, i), &value, arena); + if (res != 0) goto failed; + asdl_seq_SET(decorator_list, i, value); + } + Py_CLEAR(tmp); + } else { + PyErr_SetString(PyExc_TypeError, "required field \"decorator_list\" missing from AsyncFunctionDef"); + return 1; + } + if (exists_not_none(obj, &PyId_returns)) { + int res; + tmp = _PyObject_GetAttrId(obj, &PyId_returns); + if (tmp == NULL) goto failed; + res = obj2ast_expr(tmp, &returns, arena); + if (res != 0) goto failed; + Py_CLEAR(tmp); + } else { + returns = NULL; + } + *out = AsyncFunctionDef(name, args, body, decorator_list, returns, + lineno, col_offset, arena); + if (*out == NULL) goto failed; + return 0; + } isinstance = PyObject_IsInstance(obj, (PyObject*)ClassDef_type); if (isinstance == -1) { return 1; @@ -3867,8 +4142,6 @@ obj2ast_stmt(PyObject* obj, stmt_ty* out, PyArena* arena) identifier name; asdl_seq* bases; asdl_seq* keywords; - expr_ty starargs; - expr_ty kwargs; asdl_seq* body; asdl_seq* decorator_list; @@ -3931,26 +4204,6 @@ obj2ast_stmt(PyObject* obj, stmt_ty* out, PyArena* arena) 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; @@ -3999,8 +4252,8 @@ obj2ast_stmt(PyObject* obj, stmt_ty* out, PyArena* arena) 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; } @@ -4237,6 +4490,90 @@ obj2ast_stmt(PyObject* obj, stmt_ty* out, PyArena* arena) if (*out == NULL) goto failed; return 0; } + isinstance = PyObject_IsInstance(obj, (PyObject*)AsyncFor_type); + if (isinstance == -1) { + return 1; + } + if (isinstance) { + expr_ty target; + expr_ty iter; + asdl_seq* body; + asdl_seq* orelse; + + if (_PyObject_HasAttrId(obj, &PyId_target)) { + int res; + tmp = _PyObject_GetAttrId(obj, &PyId_target); + if (tmp == NULL) goto failed; + res = obj2ast_expr(tmp, &target, arena); + if (res != 0) goto failed; + Py_CLEAR(tmp); + } else { + PyErr_SetString(PyExc_TypeError, "required field \"target\" missing from AsyncFor"); + return 1; + } + if (_PyObject_HasAttrId(obj, &PyId_iter)) { + int res; + tmp = _PyObject_GetAttrId(obj, &PyId_iter); + if (tmp == NULL) goto failed; + res = obj2ast_expr(tmp, &iter, arena); + if (res != 0) goto failed; + Py_CLEAR(tmp); + } else { + PyErr_SetString(PyExc_TypeError, "required field \"iter\" missing from AsyncFor"); + return 1; + } + if (_PyObject_HasAttrId(obj, &PyId_body)) { + int res; + Py_ssize_t len; + Py_ssize_t i; + tmp = _PyObject_GetAttrId(obj, &PyId_body); + if (tmp == NULL) goto failed; + if (!PyList_Check(tmp)) { + PyErr_Format(PyExc_TypeError, "AsyncFor field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name); + goto failed; + } + len = PyList_GET_SIZE(tmp); + body = _Py_asdl_seq_new(len, arena); + if (body == NULL) goto failed; + for (i = 0; i < len; i++) { + stmt_ty value; + res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena); + if (res != 0) goto failed; + asdl_seq_SET(body, i, value); + } + Py_CLEAR(tmp); + } else { + PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from AsyncFor"); + return 1; + } + if (_PyObject_HasAttrId(obj, &PyId_orelse)) { + int res; + Py_ssize_t len; + Py_ssize_t i; + tmp = _PyObject_GetAttrId(obj, &PyId_orelse); + if (tmp == NULL) goto failed; + if (!PyList_Check(tmp)) { + PyErr_Format(PyExc_TypeError, "AsyncFor field \"orelse\" must be a list, not a %.200s", tmp->ob_type->tp_name); + goto failed; + } + len = PyList_GET_SIZE(tmp); + orelse = _Py_asdl_seq_new(len, arena); + if (orelse == NULL) goto failed; + for (i = 0; i < len; i++) { + stmt_ty value; + res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena); + if (res != 0) goto failed; + asdl_seq_SET(orelse, i, value); + } + Py_CLEAR(tmp); + } else { + PyErr_SetString(PyExc_TypeError, "required field \"orelse\" missing from AsyncFor"); + return 1; + } + *out = AsyncFor(target, iter, body, orelse, lineno, col_offset, arena); + if (*out == NULL) goto failed; + return 0; + } isinstance = PyObject_IsInstance(obj, (PyObject*)While_type); if (isinstance == -1) { return 1; @@ -4441,6 +4778,66 @@ obj2ast_stmt(PyObject* obj, stmt_ty* out, PyArena* arena) if (*out == NULL) goto failed; return 0; } + isinstance = PyObject_IsInstance(obj, (PyObject*)AsyncWith_type); + if (isinstance == -1) { + return 1; + } + if (isinstance) { + asdl_seq* items; + asdl_seq* body; + + if (_PyObject_HasAttrId(obj, &PyId_items)) { + int res; + Py_ssize_t len; + Py_ssize_t i; + tmp = _PyObject_GetAttrId(obj, &PyId_items); + if (tmp == NULL) goto failed; + if (!PyList_Check(tmp)) { + PyErr_Format(PyExc_TypeError, "AsyncWith field \"items\" must be a list, not a %.200s", tmp->ob_type->tp_name); + goto failed; + } + len = PyList_GET_SIZE(tmp); + items = _Py_asdl_seq_new(len, arena); + if (items == NULL) goto failed; + for (i = 0; i < len; i++) { + withitem_ty value; + res = obj2ast_withitem(PyList_GET_ITEM(tmp, i), &value, arena); + if (res != 0) goto failed; + asdl_seq_SET(items, i, value); + } + Py_CLEAR(tmp); + } else { + PyErr_SetString(PyExc_TypeError, "required field \"items\" missing from AsyncWith"); + return 1; + } + if (_PyObject_HasAttrId(obj, &PyId_body)) { + int res; + Py_ssize_t len; + Py_ssize_t i; + tmp = _PyObject_GetAttrId(obj, &PyId_body); + if (tmp == NULL) goto failed; + if (!PyList_Check(tmp)) { + PyErr_Format(PyExc_TypeError, "AsyncWith field \"body\" must be a list, not a %.200s", tmp->ob_type->tp_name); + goto failed; + } + len = PyList_GET_SIZE(tmp); + body = _Py_asdl_seq_new(len, arena); + if (body == NULL) goto failed; + for (i = 0; i < len; i++) { + stmt_ty value; + res = obj2ast_stmt(PyList_GET_ITEM(tmp, i), &value, arena); + if (res != 0) goto failed; + asdl_seq_SET(body, i, value); + } + Py_CLEAR(tmp); + } else { + PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from AsyncWith"); + return 1; + } + *out = AsyncWith(items, body, lineno, col_offset, arena); + if (*out == NULL) goto failed; + return 0; + } isinstance = PyObject_IsInstance(obj, (PyObject*)Raise_type); if (isinstance == -1) { return 1; @@ -5375,6 +5772,28 @@ obj2ast_expr(PyObject* obj, expr_ty* out, PyArena* arena) if (*out == NULL) goto failed; return 0; } + isinstance = PyObject_IsInstance(obj, (PyObject*)Await_type); + if (isinstance == -1) { + return 1; + } + if (isinstance) { + expr_ty value; + + if (_PyObject_HasAttrId(obj, &PyId_value)) { + int res; + tmp = _PyObject_GetAttrId(obj, &PyId_value); + if (tmp == NULL) goto failed; + res = obj2ast_expr(tmp, &value, arena); + if (res != 0) goto failed; + Py_CLEAR(tmp); + } else { + PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Await"); + return 1; + } + *out = Await(value, lineno, col_offset, arena); + if (*out == NULL) goto failed; + return 0; + } isinstance = PyObject_IsInstance(obj, (PyObject*)Yield_type); if (isinstance == -1) { return 1; @@ -5498,8 +5917,6 @@ obj2ast_expr(PyObject* obj, expr_ty* out, PyArena* arena) expr_ty func; asdl_seq* args; asdl_seq* keywords; - expr_ty starargs; - expr_ty kwargs; if (_PyObject_HasAttrId(obj, &PyId_func)) { int res; @@ -5560,28 +5977,7 @@ obj2ast_expr(PyObject* obj, expr_ty* out, PyArena* arena) 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; } @@ -6175,6 +6571,14 @@ obj2ast_operator(PyObject* obj, operator_ty* out, PyArena* arena) *out = Mult; return 0; } + isinstance = PyObject_IsInstance(obj, (PyObject *)MatMult_type); + if (isinstance == -1) { + return 1; + } + if (isinstance) { + *out = MatMult; + return 0; + } isinstance = PyObject_IsInstance(obj, (PyObject *)Div_type); if (isinstance == -1) { return 1; @@ -6685,6 +7089,8 @@ obj2ast_arg(PyObject* obj, arg_ty* out, PyArena* arena) PyObject* tmp = NULL; identifier arg; expr_ty annotation; + int lineno; + int col_offset; if (_PyObject_HasAttrId(obj, &PyId_arg)) { int res; @@ -6707,7 +7113,29 @@ obj2ast_arg(PyObject* obj, arg_ty* out, PyArena* arena) } else { annotation = NULL; } - *out = arg(arg, annotation, arena); + if (_PyObject_HasAttrId(obj, &PyId_lineno)) { + int res; + tmp = _PyObject_GetAttrId(obj, &PyId_lineno); + if (tmp == NULL) goto failed; + res = obj2ast_int(tmp, &lineno, arena); + if (res != 0) goto failed; + Py_CLEAR(tmp); + } else { + PyErr_SetString(PyExc_TypeError, "required field \"lineno\" missing from arg"); + return 1; + } + if (_PyObject_HasAttrId(obj, &PyId_col_offset)) { + int res; + tmp = _PyObject_GetAttrId(obj, &PyId_col_offset); + if (tmp == NULL) goto failed; + res = obj2ast_int(tmp, &col_offset, arena); + if (res != 0) goto failed; + Py_CLEAR(tmp); + } else { + PyErr_SetString(PyExc_TypeError, "required field \"col_offset\" missing from arg"); + return 1; + } + *out = arg(arg, annotation, lineno, col_offset, arena); return 0; failed: Py_XDECREF(tmp); @@ -6721,7 +7149,7 @@ obj2ast_keyword(PyObject* obj, keyword_ty* out, PyArena* arena) 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; @@ -6729,8 +7157,7 @@ obj2ast_keyword(PyObject* obj, keyword_ty* out, PyArena* arena) 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; @@ -6847,6 +7274,8 @@ PyInit__ast(void) if (PyDict_SetItemString(d, "stmt", (PyObject*)stmt_type) < 0) return NULL; if (PyDict_SetItemString(d, "FunctionDef", (PyObject*)FunctionDef_type) < 0) return NULL; + if (PyDict_SetItemString(d, "AsyncFunctionDef", + (PyObject*)AsyncFunctionDef_type) < 0) return NULL; if (PyDict_SetItemString(d, "ClassDef", (PyObject*)ClassDef_type) < 0) return NULL; if (PyDict_SetItemString(d, "Return", (PyObject*)Return_type) < 0) return @@ -6858,10 +7287,14 @@ PyInit__ast(void) if (PyDict_SetItemString(d, "AugAssign", (PyObject*)AugAssign_type) < 0) return NULL; if (PyDict_SetItemString(d, "For", (PyObject*)For_type) < 0) return NULL; + if (PyDict_SetItemString(d, "AsyncFor", (PyObject*)AsyncFor_type) < 0) + return NULL; if (PyDict_SetItemString(d, "While", (PyObject*)While_type) < 0) return NULL; if (PyDict_SetItemString(d, "If", (PyObject*)If_type) < 0) return NULL; if (PyDict_SetItemString(d, "With", (PyObject*)With_type) < 0) return NULL; + if (PyDict_SetItemString(d, "AsyncWith", (PyObject*)AsyncWith_type) < 0) + return NULL; if (PyDict_SetItemString(d, "Raise", (PyObject*)Raise_type) < 0) return NULL; if (PyDict_SetItemString(d, "Try", (PyObject*)Try_type) < 0) return NULL; @@ -6902,6 +7335,8 @@ PyInit__ast(void) return NULL; if (PyDict_SetItemString(d, "GeneratorExp", (PyObject*)GeneratorExp_type) < 0) return NULL; + if (PyDict_SetItemString(d, "Await", (PyObject*)Await_type) < 0) return + NULL; if (PyDict_SetItemString(d, "Yield", (PyObject*)Yield_type) < 0) return NULL; if (PyDict_SetItemString(d, "YieldFrom", (PyObject*)YieldFrom_type) < 0) @@ -6956,6 +7391,8 @@ PyInit__ast(void) if (PyDict_SetItemString(d, "Add", (PyObject*)Add_type) < 0) return NULL; if (PyDict_SetItemString(d, "Sub", (PyObject*)Sub_type) < 0) return NULL; if (PyDict_SetItemString(d, "Mult", (PyObject*)Mult_type) < 0) return NULL; + if (PyDict_SetItemString(d, "MatMult", (PyObject*)MatMult_type) < 0) return + NULL; if (PyDict_SetItemString(d, "Div", (PyObject*)Div_type) < 0) return NULL; if (PyDict_SetItemString(d, "Mod", (PyObject*)Mod_type) < 0) return NULL; if (PyDict_SetItemString(d, "Pow", (PyObject*)Pow_type) < 0) return NULL; diff --git a/Python/README b/Python/README new file mode 100644 index 0000000000..153b628bd5 --- /dev/null +++ b/Python/README @@ -0,0 +1 @@ +Miscellaneous source files for the main Python shared library diff --git a/Python/_warnings.c b/Python/_warnings.c index 6dff0a2c11..9ca83145c9 100644 --- a/Python/_warnings.c +++ b/Python/_warnings.c @@ -513,6 +513,64 @@ warn_explicit(PyObject *category, PyObject *message, return result; /* Py_None or NULL. */ } +static int +is_internal_frame(PyFrameObject *frame) +{ + static PyObject *importlib_string = NULL; + static PyObject *bootstrap_string = NULL; + PyObject *filename; + int contains; + + if (importlib_string == NULL) { + importlib_string = PyUnicode_FromString("importlib"); + if (importlib_string == NULL) { + return 0; + } + + bootstrap_string = PyUnicode_FromString("_bootstrap"); + if (bootstrap_string == NULL) { + Py_DECREF(importlib_string); + return 0; + } + Py_INCREF(importlib_string); + Py_INCREF(bootstrap_string); + } + + if (frame == NULL || frame->f_code == NULL || + frame->f_code->co_filename == NULL) { + return 0; + } + filename = frame->f_code->co_filename; + if (!PyUnicode_Check(filename)) { + return 0; + } + contains = PyUnicode_Contains(filename, importlib_string); + if (contains < 0) { + return 0; + } + else if (contains > 0) { + contains = PyUnicode_Contains(filename, bootstrap_string); + if (contains < 0) { + return 0; + } + else if (contains > 0) { + return 1; + } + } + + return 0; +} + +static PyFrameObject * +next_external_frame(PyFrameObject *frame) +{ + do { + frame = frame->f_back; + } while (frame != NULL && is_internal_frame(frame)); + + return frame; +} + /* filename, module, and registry are new refs, globals is borrowed */ /* Returns 0 on error (no new refs), 1 on success */ static int @@ -523,8 +581,18 @@ setup_context(Py_ssize_t stack_level, PyObject **filename, int *lineno, /* Setup globals and lineno. */ PyFrameObject *f = PyThreadState_GET()->frame; - while (--stack_level > 0 && f != NULL) - f = f->f_back; + // Stack level comparisons to Python code is off by one as there is no + // warnings-related stack level to avoid. + if (stack_level <= 0 || is_internal_frame(f)) { + while (--stack_level > 0 && f != NULL) { + f = f->f_back; + } + } + else { + while (--stack_level > 0 && f != NULL) { + f = next_external_frame(f); + } + } if (f == NULL) { globals = PyThreadState_Get()->interp->sysdict; @@ -580,13 +648,12 @@ setup_context(Py_ssize_t stack_level, PyObject **filename, int *lineno, data = PyUnicode_DATA(*filename); #define ascii_lower(c) ((c <= 127) ? Py_TOLOWER(c) : 0) - /* if filename.lower().endswith((".pyc", ".pyo")): */ + /* if filename.lower().endswith(".pyc"): */ if (len >= 4 && PyUnicode_READ(kind, data, len-4) == '.' && ascii_lower(PyUnicode_READ(kind, data, len-3)) == 'p' && ascii_lower(PyUnicode_READ(kind, data, len-2)) == 'y' && - (ascii_lower(PyUnicode_READ(kind, data, len-1)) == 'c' || - ascii_lower(PyUnicode_READ(kind, data, len-1)) == 'o')) + ascii_lower(PyUnicode_READ(kind, data, len-1)) == 'c') { *filename = PyUnicode_Substring(*filename, 0, PyUnicode_GET_LENGTH(*filename)-1); @@ -654,16 +721,17 @@ get_category(PyObject *message, PyObject *category) if (rc == 1) category = (PyObject*)message->ob_type; - else if (category == NULL) + else if (category == NULL || category == Py_None) category = PyExc_UserWarning; /* Validate category. */ rc = PyObject_IsSubclass(category, PyExc_Warning); - if (rc == -1) - return NULL; - if (rc == 0) { - PyErr_SetString(PyExc_ValueError, - "category is not a subclass of Warning"); + /* category is not a subclass of PyExc_Warning or + PyObject_IsSubclass raised an error */ + if (rc == -1 || rc == 0) { + PyErr_Format(PyExc_TypeError, + "category must be a Warning subclass, not '%s'", + Py_TYPE(category)->tp_name); return NULL; } diff --git a/Python/asdl.c b/Python/asdl.c index 74fa9410e4..df387b2119 100644 --- a/Python/asdl.c +++ b/Python/asdl.c @@ -5,21 +5,21 @@ asdl_seq * _Py_asdl_seq_new(Py_ssize_t size, PyArena *arena) { asdl_seq *seq = NULL; - size_t n = (size ? (sizeof(void *) * (size - 1)) : 0); + size_t n; /* check size is sane */ - if (size < 0 || size == INT_MIN || - (size && ((size - 1) > (PY_SIZE_MAX / sizeof(void *))))) { + if (size < 0 || + (size && (((size_t)size - 1) > (PY_SIZE_MAX / sizeof(void *))))) { PyErr_NoMemory(); return NULL; } + n = (size ? (sizeof(void *) * (size - 1)) : 0); /* check if size can be added safely */ if (n > PY_SIZE_MAX - sizeof(asdl_seq)) { PyErr_NoMemory(); return NULL; } - n += sizeof(asdl_seq); seq = (asdl_seq *)PyArena_Malloc(arena, n); @@ -36,21 +36,21 @@ asdl_int_seq * _Py_asdl_int_seq_new(Py_ssize_t size, PyArena *arena) { asdl_int_seq *seq = NULL; - size_t n = (size ? (sizeof(void *) * (size - 1)) : 0); + size_t n; /* check size is sane */ - if (size < 0 || size == INT_MIN || - (size && ((size - 1) > (PY_SIZE_MAX / sizeof(void *))))) { + if (size < 0 || + (size && (((size_t)size - 1) > (PY_SIZE_MAX / sizeof(void *))))) { PyErr_NoMemory(); return NULL; } + n = (size ? (sizeof(void *) * (size - 1)) : 0); /* check if size can be added safely */ if (n > PY_SIZE_MAX - sizeof(asdl_seq)) { PyErr_NoMemory(); return NULL; } - n += sizeof(asdl_seq); seq = (asdl_int_seq *)PyArena_Malloc(arena, n); diff --git a/Python/ast.c b/Python/ast.c index d50cb80f24..7743c31c1f 100644 --- a/Python/ast.c +++ b/Python/ast.c @@ -115,7 +115,7 @@ validate_arguments(arguments_ty args) } if (!validate_args(args->kwonlyargs)) return 0; - if (args->kwarg && args->kwarg->annotation + if (args->kwarg && args->kwarg->annotation && !validate_expr(args->kwarg->annotation, Load)) { return 0; } @@ -164,6 +164,8 @@ validate_expr(expr_ty exp, expr_context_ty ctx) return 0; } check_ctx = 0; + /* set actual_ctx to prevent gcc warning */ + actual_ctx = 0; } if (check_ctx && actual_ctx != ctx) { PyErr_Format(PyExc_ValueError, "expression must have %s context but has %s instead", @@ -197,8 +199,10 @@ validate_expr(expr_ty exp, expr_context_ty ctx) "Dict doesn't have the same number of keys as values"); return 0; } - return validate_exprs(exp->v.Dict.keys, Load, 0) && - validate_exprs(exp->v.Dict.values, Load, 0); + /* null_ok=1 for keys expressions to allow dict unpacking to work in + dict literals, i.e. ``{**{a:b}}`` */ + return validate_exprs(exp->v.Dict.keys, Load, /*null_ok=*/ 1) && + validate_exprs(exp->v.Dict.values, Load, /*null_ok=*/ 0); case Set_kind: return validate_exprs(exp->v.Set.elts, Load, 0); #define COMP(NAME) \ @@ -217,6 +221,8 @@ validate_expr(expr_ty exp, expr_context_ty ctx) return !exp->v.Yield.value || validate_expr(exp->v.Yield.value, Load); case YieldFrom_kind: return validate_expr(exp->v.YieldFrom.value, Load); + case Await_kind: + return validate_expr(exp->v.Await.value, Load); case Compare_kind: if (!asdl_seq_LEN(exp->v.Compare.comparators)) { PyErr_SetString(PyExc_ValueError, "Compare with no comparators"); @@ -233,9 +239,7 @@ validate_expr(expr_ty exp, expr_context_ty ctx) 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) && @@ -320,9 +324,7 @@ validate_stmt(stmt_ty stmt) 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: @@ -338,6 +340,11 @@ validate_stmt(stmt_ty stmt) validate_expr(stmt->v.For.iter, Load) && validate_body(stmt->v.For.body, "For") && validate_stmts(stmt->v.For.orelse); + case AsyncFor_kind: + return validate_expr(stmt->v.AsyncFor.target, Store) && + validate_expr(stmt->v.AsyncFor.iter, Load) && + validate_body(stmt->v.AsyncFor.body, "AsyncFor") && + validate_stmts(stmt->v.AsyncFor.orelse); case While_kind: return validate_expr(stmt->v.While.test, Load) && validate_body(stmt->v.While.body, "While") && @@ -356,6 +363,16 @@ validate_stmt(stmt_ty stmt) return 0; } return validate_body(stmt->v.With.body, "With"); + case AsyncWith_kind: + if (!validate_nonempty_seq(stmt->v.AsyncWith.items, "items", "AsyncWith")) + return 0; + for (i = 0; i < asdl_seq_LEN(stmt->v.AsyncWith.items); i++) { + withitem_ty item = asdl_seq_GET(stmt->v.AsyncWith.items, i); + if (!validate_expr(item->context_expr, Load) || + (item->optional_vars && !validate_expr(item->optional_vars, Store))) + return 0; + } + return validate_body(stmt->v.AsyncWith.body, "AsyncWith"); case Raise_kind: if (stmt->v.Raise.exc) { return validate_expr(stmt->v.Raise.exc, Load) && @@ -407,6 +424,12 @@ validate_stmt(stmt_ty stmt) return validate_nonempty_seq(stmt->v.Nonlocal.names, "names", "Nonlocal"); case Expr_kind: return validate_expr(stmt->v.Expr.value, Load); + case AsyncFunctionDef_kind: + return validate_body(stmt->v.AsyncFunctionDef.body, "AsyncFunctionDef") && + validate_arguments(stmt->v.AsyncFunctionDef.args) && + validate_exprs(stmt->v.AsyncFunctionDef.decorator_list, Load, 0) && + (!stmt->v.AsyncFunctionDef.returns || + validate_expr(stmt->v.AsyncFunctionDef.returns, Load)); case Pass_kind: case Break_kind: case Continue_kind: @@ -451,7 +474,7 @@ validate_exprs(asdl_seq *exprs, expr_context_ty ctx, int null_ok) "None disallowed in expression list"); return 0; } - + } return 1; } @@ -505,6 +528,9 @@ static asdl_seq *ast_for_exprlist(struct compiling *, const node *, static expr_ty ast_for_testlist(struct compiling *, const node *); static stmt_ty ast_for_classdef(struct compiling *, const node *, asdl_seq *); +static stmt_ty ast_for_with_stmt(struct compiling *, const node *, int); +static stmt_ty ast_for_for_stmt(struct compiling *, const node *, int); + /* Note different signature for ast_for_call */ static expr_ty ast_for_call(struct compiling *, const node *, expr_ty); @@ -825,6 +851,8 @@ get_operator(const node *n) return Sub; case STAR: return Mult; + case AT: + return MatMult; case SLASH: return Div; case DOUBLESLASH: @@ -844,7 +872,8 @@ static const char* FORBIDDEN[] = { }; 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) { @@ -940,6 +969,9 @@ set_context(struct compiling *c, expr_ty e, expr_context_ty ctx, const node *n) case YieldFrom_kind: expr_name = "yield expression"; break; + case Await_kind: + expr_name = "await expression"; + break; case ListComp_kind: expr_name = "list comprehension"; break; @@ -1030,6 +1062,8 @@ ast_for_augassign(struct compiling *c, const node *n) return Pow; else return Mult; + case '@': + return MatMult; default: PyErr_Format(PyExc_SystemError, "invalid augassign: %s", STR(n)); return (operator_ty)0; @@ -1139,11 +1173,9 @@ ast_for_arg(struct compiling *c, const node *n) return NULL; } - ret = arg(name, annotation, c->c_arena); + ret = arg(name, annotation, LINENO(n), n->n_col_offset, c->c_arena); if (!ret) return NULL; - ret->lineno = LINENO(n); - ret->col_offset = n->n_col_offset; return ret; } @@ -1199,11 +1231,10 @@ handle_keywordonly_args(struct compiling *c, const node *n, int start, goto error; if (forbidden_name(c, argname, ch, 0)) goto error; - arg = arg(argname, annotation, c->c_arena); + arg = arg(argname, annotation, LINENO(ch), ch->n_col_offset, + c->c_arena); if (!arg) goto error; - arg->lineno = LINENO(ch); - arg->col_offset = ch->n_col_offset; asdl_seq_SET(kwonlyargs, j++, arg); i += 2; /* the name and the comma */ break; @@ -1439,7 +1470,7 @@ ast_for_decorator(struct compiling *c, const node *n) 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; @@ -1477,7 +1508,8 @@ ast_for_decorators(struct compiling *c, const node *n) } static stmt_ty -ast_for_funcdef(struct compiling *c, const node *n, asdl_seq *decorator_seq) +ast_for_funcdef_impl(struct compiling *c, const node *n, + asdl_seq *decorator_seq, int is_async) { /* funcdef: 'def' NAME parameters ['->' test] ':' suite */ identifier name; @@ -1506,14 +1538,68 @@ ast_for_funcdef(struct compiling *c, const node *n, asdl_seq *decorator_seq) if (!body) return NULL; - return FunctionDef(name, args, body, decorator_seq, returns, LINENO(n), - n->n_col_offset, c->c_arena); + if (is_async) + return AsyncFunctionDef(name, args, body, decorator_seq, returns, + LINENO(n), + n->n_col_offset, c->c_arena); + else + return FunctionDef(name, args, body, decorator_seq, returns, + LINENO(n), + n->n_col_offset, c->c_arena); +} + +static stmt_ty +ast_for_async_funcdef(struct compiling *c, const node *n, asdl_seq *decorator_seq) +{ + /* async_funcdef: ASYNC funcdef */ + REQ(n, async_funcdef); + REQ(CHILD(n, 0), ASYNC); + REQ(CHILD(n, 1), funcdef); + + return ast_for_funcdef_impl(c, CHILD(n, 1), decorator_seq, + 1 /* is_async */); +} + +static stmt_ty +ast_for_funcdef(struct compiling *c, const node *n, asdl_seq *decorator_seq) +{ + /* funcdef: 'def' NAME parameters ['->' test] ':' suite */ + return ast_for_funcdef_impl(c, n, decorator_seq, + 0 /* is_async */); +} + + +static stmt_ty +ast_for_async_stmt(struct compiling *c, const node *n) +{ + /* async_stmt: ASYNC (funcdef | with_stmt | for_stmt) */ + REQ(n, async_stmt); + REQ(CHILD(n, 0), ASYNC); + + switch (TYPE(CHILD(n, 1))) { + case funcdef: + return ast_for_funcdef_impl(c, CHILD(n, 1), NULL, + 1 /* is_async */); + case with_stmt: + return ast_for_with_stmt(c, CHILD(n, 1), + 1 /* is_async */); + + case for_stmt: + return ast_for_for_stmt(c, CHILD(n, 1), + 1 /* is_async */); + + default: + PyErr_Format(PyExc_SystemError, + "invalid async stament: %s", + STR(CHILD(n, 1))); + return NULL; + } } static stmt_ty ast_for_decorated(struct compiling *c, const node *n) { - /* decorated: decorators (classdef | funcdef) */ + /* decorated: decorators (classdef | funcdef | async_funcdef) */ stmt_ty thing = NULL; asdl_seq *decorator_seq = NULL; @@ -1524,12 +1610,15 @@ ast_for_decorated(struct compiling *c, const node *n) return NULL; assert(TYPE(CHILD(n, 1)) == funcdef || + TYPE(CHILD(n, 1)) == async_funcdef || TYPE(CHILD(n, 1)) == classdef); if (TYPE(CHILD(n, 1)) == funcdef) { thing = ast_for_funcdef(c, CHILD(n, 1), decorator_seq); } else if (TYPE(CHILD(n, 1)) == classdef) { thing = ast_for_classdef(c, CHILD(n, 1), decorator_seq); + } else if (TYPE(CHILD(n, 1)) == async_funcdef) { + thing = ast_for_async_funcdef(c, CHILD(n, 1), decorator_seq); } /* we count the decorators in when talking about the class' or * function's line number */ @@ -1729,16 +1818,22 @@ ast_for_comprehension(struct compiling *c, const node *n) 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) @@ -1755,23 +1850,59 @@ ast_for_itercomp(struct compiling *c, const node *n, int type) 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; + int i = 0; - assert(NCH(n) > 3); - REQ(CHILD(n, 1), COLON); - - key = ast_for_expr(c, CHILD(n, 0)); - if (!key) - return NULL; - value = ast_for_expr(c, CHILD(n, 2)); - if (!value) + if (!ast_for_dictelement(c, n, &i, &key, &value)) return NULL; + assert(key); + assert(NCH(n) - i >= 1); - comps = ast_for_comprehension(c, CHILD(n, 3)); + comps = ast_for_comprehension(c, CHILD(n, i)); if (!comps) return NULL; @@ -1779,6 +1910,39 @@ ast_for_dictcomp(struct compiling *c, const node *n) } 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)); @@ -1799,6 +1963,27 @@ ast_for_setcomp(struct compiling *c, const node *n) 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) @@ -1909,62 +2094,48 @@ ast_for_atom(struct compiling *c, const node *n) 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))* [','])) ) */ + expr_ty res; 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) - return NULL; - asdl_seq_SET(elts, i / 2, 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. */ + res = ast_for_setdisplay(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) + else if (NCH(ch) > 1 && + TYPE(CHILD(ch, 1)) == comp_for) { + /* It's a set comprehension. */ + res = 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(values, i / 4, expression); + } + res = ast_for_dictcomp(c, ch); + } + else { + /* It's a dictionary display. */ + res = ast_for_dictdisplay(c, ch); } - return Dict(keys, values, LINENO(n), n->n_col_offset, c->c_arena); + if (res) { + res->lineno = LINENO(n); + res->col_offset = n->n_col_offset; + } + return res; } } default: @@ -2100,7 +2271,7 @@ ast_for_trailer(struct compiling *c, const node *n, expr_ty left_expr) 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); @@ -2192,19 +2363,29 @@ ast_for_factor(struct compiling *c, const node *n) } static expr_ty -ast_for_power(struct compiling *c, const node *n) +ast_for_atom_expr(struct compiling *c, const node *n) { - /* power: atom trailer* ('**' factor)* - */ - int i; + int i, nch, start = 0; expr_ty e, tmp; - REQ(n, power); - e = ast_for_atom(c, CHILD(n, 0)); + + REQ(n, atom_expr); + nch = NCH(n); + + if (TYPE(CHILD(n, 0)) == AWAIT) { + start = 1; + assert(nch > 1); + } + + e = ast_for_atom(c, CHILD(n, start)); if (!e) return NULL; - if (NCH(n) == 1) + if (nch == 1) return e; - for (i = 1; i < NCH(n); i++) { + if (start && nch == 2) { + return Await(e, LINENO(n), n->n_col_offset, c->c_arena); + } + + for (i = start + 1; i < nch; i++) { node *ch = CHILD(n, i); if (TYPE(ch) != trailer) break; @@ -2215,6 +2396,28 @@ ast_for_power(struct compiling *c, const node *n) tmp->col_offset = e->col_offset; e = tmp; } + + if (start) { + /* there was an AWAIT */ + return Await(e, LINENO(n), n->n_col_offset, c->c_arena); + } + else { + return e; + } +} + +static expr_ty +ast_for_power(struct compiling *c, const node *n) +{ + /* power: atom trailer* ('**' factor)* + */ + expr_ty e; + REQ(n, power); + e = ast_for_atom_expr(c, CHILD(n, 0)); + if (!e) + return NULL; + if (NCH(n) == 1) + return e; if (TYPE(CHILD(n, NCH(n) - 1)) == factor) { expr_ty f = ast_for_expr(c, CHILD(n, NCH(n) - 1)); if (!f) @@ -2257,9 +2460,11 @@ ast_for_expr(struct compiling *c, const node *n) and_expr: shift_expr ('&' shift_expr)* shift_expr: arith_expr (('<<'|'>>') arith_expr)* arith_expr: term (('+'|'-') term)* - term: factor (('*'|'/'|'%'|'//') factor)* + term: factor (('*'|'@'|'/'|'%'|'//') factor)* factor: ('+'|'-'|'~') factor | power - power: atom trailer* ('**' factor)* + power: atom_expr ['**' factor] + atom_expr: [AWAIT] atom trailer* + yield_expr: 'yield' [yield_arg] */ asdl_seq *seq; @@ -2409,15 +2614,14 @@ static expr_ty 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); @@ -2431,7 +2635,10 @@ ast_for_call(struct compiling *c, const node *n, expr_ty func) 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++; } } @@ -2452,41 +2659,81 @@ ast_for_call(struct compiling *c, const node *n, expr_ty func) 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) { + /* a positional argument */ if (nkeywords) { - ast_error(c, CHILD(ch, 0), - "non-keyword arg after keyword arg"); + if (ndoublestars) { + ast_error(c, chch, + "positional argument follows " + "keyword argument unpacking"); + } + else { + ast_error(c, chch, + "positional argument follows " + "keyword argument"); + } return NULL; } - if (vararg) { - ast_error(c, CHILD(ch, 0), - "only named arguments may follow *expression"); + e = ast_for_expr(c, chch); + if (!e) + return NULL; + asdl_seq_SET(args, nargs++, e); + } + else if (TYPE(chch) == STAR) { + /* 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(ch, 0)); + e = ast_for_expr(c, CHILD(ch, 1)); if (!e) return NULL; - asdl_seq_SET(args, nargs++, e); + starred = Starred(e, Load, LINENO(chch), + chch->n_col_offset, + c->c_arena); + if (!starred) + return NULL; + asdl_seq_SET(args, nargs++, starred); + + } + 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; + 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 @@ -2495,19 +2742,24 @@ ast_for_call(struct compiling *c, const node *n, expr_ty func) * 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; } } @@ -2520,21 +2772,9 @@ ast_for_call(struct compiling *c, const node *n, expr_ty func) 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 @@ -2568,7 +2808,7 @@ ast_for_expr_stmt(struct compiling *c, const node *n) /* expr_stmt: testlist_star_expr (augassign (yield_expr|testlist) | ('=' (yield_expr|testlist))*) testlist_star_expr: (test|star_expr) (',' test|star_expr)* [','] - augassign: '+=' | '-=' | '*=' | '/=' | '%=' | '&=' | '|=' | '^=' + augassign: '+=' | '-=' | '*=' | '@=' | '/=' | '%=' | '&=' | '|=' | '^=' | '<<=' | '>>=' | '**=' | '//=' test: ... here starts the operator precendence dance */ @@ -3288,7 +3528,7 @@ ast_for_while_stmt(struct compiling *c, const node *n) } static stmt_ty -ast_for_for_stmt(struct compiling *c, const node *n) +ast_for_for_stmt(struct compiling *c, const node *n, int is_async) { asdl_seq *_target, *seq = NULL, *suite_seq; expr_ty expression; @@ -3322,8 +3562,14 @@ ast_for_for_stmt(struct compiling *c, const node *n) if (!suite_seq) return NULL; - return For(target, expression, suite_seq, seq, LINENO(n), n->n_col_offset, - c->c_arena); + if (is_async) + return AsyncFor(target, expression, suite_seq, seq, + LINENO(n), n->n_col_offset, + c->c_arena); + else + return For(target, expression, suite_seq, seq, + LINENO(n), n->n_col_offset, + c->c_arena); } static excepthandler_ty @@ -3470,7 +3716,7 @@ ast_for_with_item(struct compiling *c, const node *n) /* with_stmt: 'with' with_item (',' with_item)* ':' suite */ static stmt_ty -ast_for_with_stmt(struct compiling *c, const node *n) +ast_for_with_stmt(struct compiling *c, const node *n, int is_async) { int i, n_items; asdl_seq *items, *body; @@ -3492,7 +3738,10 @@ ast_for_with_stmt(struct compiling *c, const node *n) if (!body) return NULL; - return With(items, body, LINENO(n), n->n_col_offset, c->c_arena); + if (is_async) + return AsyncWith(items, body, LINENO(n), n->n_col_offset, c->c_arena); + else + return With(items, body, LINENO(n), n->n_col_offset, c->c_arena); } static stmt_ty @@ -3514,8 +3763,8 @@ ast_for_classdef(struct compiling *c, const node *n, asdl_seq *decorator_seq) 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 */ @@ -3527,8 +3776,8 @@ ast_for_classdef(struct compiling *c, const node *n, asdl_seq *decorator_seq) 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 */ @@ -3553,8 +3802,7 @@ ast_for_classdef(struct compiling *c, const node *n, asdl_seq *decorator_seq) 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); } @@ -3600,7 +3848,7 @@ ast_for_stmt(struct compiling *c, const node *n) } else { /* compound_stmt: if_stmt | while_stmt | for_stmt | try_stmt - | funcdef | classdef | decorated + | funcdef | classdef | decorated | async_stmt */ node *ch = CHILD(n, 0); REQ(n, compound_stmt); @@ -3610,17 +3858,19 @@ ast_for_stmt(struct compiling *c, const node *n) case while_stmt: return ast_for_while_stmt(c, ch); case for_stmt: - return ast_for_for_stmt(c, ch); + return ast_for_for_stmt(c, ch, 0); case try_stmt: return ast_for_try_stmt(c, ch); case with_stmt: - return ast_for_with_stmt(c, ch); + return ast_for_with_stmt(c, ch, 0); case funcdef: return ast_for_funcdef(c, ch, NULL); case classdef: return ast_for_classdef(c, ch, NULL); case decorated: return ast_for_decorated(c, ch); + case async_stmt: + return ast_for_async_stmt(c, ch); default: PyErr_Format(PyExc_SystemError, "unhandled small_stmt: TYPE=%d NCH=%d\n", diff --git a/Python/bltinmodule.c b/Python/bltinmodule.c index 53009e3fbd..a06ef610c6 100644 --- a/Python/bltinmodule.c +++ b/Python/bltinmodule.c @@ -46,13 +46,16 @@ _Py_IDENTIFIER(stdin); _Py_IDENTIFIER(stdout); _Py_IDENTIFIER(stderr); +#include "clinic/bltinmodule.c.h" + +/* AC: cannot convert yet, waiting for *args support */ static PyObject * builtin___build_class__(PyObject *self, PyObject *args, PyObject *kwds) { PyObject *func, *name, *bases, *mkw, *meta, *winner, *prep, *ns, *cell; PyObject *cls = NULL; Py_ssize_t nargs; - int isclass; + int isclass = 0; /* initialize to prevent gcc warning */ assert(args != NULL); if (!PyTuple_Check(args)) { @@ -229,25 +232,42 @@ absolute or relative imports. 0 is absolute while a positive number\n\ is the number of parent directories to search relative to the current module."); +/*[clinic input] +abs as builtin_abs + + x: object + / + +Return the absolute value of the argument. +[clinic start generated code]*/ + static PyObject * -builtin_abs(PyObject *self, PyObject *v) +builtin_abs(PyModuleDef *module, PyObject *x) +/*[clinic end generated code: output=6833047c493ecea2 input=bed4ca14e29c20d1]*/ { - return PyNumber_Absolute(v); + return PyNumber_Absolute(x); } -PyDoc_STRVAR(abs_doc, -"abs(number) -> number\n\ -\n\ -Return the absolute value of the argument."); +/*[clinic input] +all as builtin_all + + iterable: object + / + +Return True if bool(x) is True for all values x in the iterable. + +If the iterable is empty, return True. +[clinic start generated code]*/ static PyObject * -builtin_all(PyObject *self, PyObject *v) +builtin_all(PyModuleDef *module, PyObject *iterable) +/*[clinic end generated code: output=089e6d1b7bde27b1 input=1a7c5d1bc3438a21]*/ { PyObject *it, *item; PyObject *(*iternext)(PyObject *); int cmp; - it = PyObject_GetIter(v); + it = PyObject_GetIter(iterable); if (it == NULL) return NULL; iternext = *Py_TYPE(it)->tp_iternext; @@ -277,20 +297,26 @@ builtin_all(PyObject *self, PyObject *v) Py_RETURN_TRUE; } -PyDoc_STRVAR(all_doc, -"all(iterable) -> bool\n\ -\n\ -Return True if bool(x) is True for all values x in the iterable.\n\ -If the iterable is empty, return True."); +/*[clinic input] +any as builtin_any + + iterable: object + / + +Return True if bool(x) is True for any x in the iterable. + +If the iterable is empty, return False. +[clinic start generated code]*/ static PyObject * -builtin_any(PyObject *self, PyObject *v) +builtin_any(PyModuleDef *module, PyObject *iterable) +/*[clinic end generated code: output=1be994b2c2307492 input=41d7451c23384f24]*/ { PyObject *it, *item; PyObject *(*iternext)(PyObject *); int cmp; - it = PyObject_GetIter(v); + it = PyObject_GetIter(iterable); if (it == NULL) return NULL; iternext = *Py_TYPE(it)->tp_iternext; @@ -320,56 +346,67 @@ builtin_any(PyObject *self, PyObject *v) Py_RETURN_FALSE; } -PyDoc_STRVAR(any_doc, -"any(iterable) -> bool\n\ -\n\ -Return True if bool(x) is True for any x in the iterable.\n\ -If the iterable is empty, return False."); +/*[clinic input] +ascii as builtin_ascii + + obj: object + / + +Return an ASCII-only representation of an object. + +As repr(), return a string containing a printable representation of an +object, but escape the non-ASCII characters in the string returned by +repr() using \\x, \\u or \\U escapes. This generates a string similar +to that returned by repr() in Python 2. +[clinic start generated code]*/ static PyObject * -builtin_ascii(PyObject *self, PyObject *v) +builtin_ascii(PyModuleDef *module, PyObject *obj) +/*[clinic end generated code: output=d4e862c48af2a933 input=4c62732e1b3a3cc9]*/ { - return PyObject_ASCII(v); + return PyObject_ASCII(obj); } -PyDoc_STRVAR(ascii_doc, -"ascii(object) -> string\n\ -\n\ -As repr(), return a string containing a printable representation of an\n\ -object, but escape the non-ASCII characters in the string returned by\n\ -repr() using \\x, \\u or \\U escapes. This generates a string similar\n\ -to that returned by repr() in Python 2."); +/*[clinic input] +bin as builtin_bin + + number: object + / + +Return the binary representation of an integer. + + >>> bin(2796202) + '0b1010101010101010101010' +[clinic start generated code]*/ static PyObject * -builtin_bin(PyObject *self, PyObject *v) +builtin_bin(PyModuleDef *module, PyObject *number) +/*[clinic end generated code: output=25ee26c6cf3bbb54 input=53f8a0264bacaf90]*/ { - return PyNumber_ToBase(v, 2); + return PyNumber_ToBase(number, 2); } -PyDoc_STRVAR(bin_doc, -"bin(number) -> string\n\ -\n\ -Return the binary representation of an integer.\n\ -\n\ - >>> bin(2796202)\n\ - '0b1010101010101010101010'\n\ -"); +/*[clinic input] +callable as builtin_callable + + obj: object + / + +Return whether the object is callable (i.e., some kind of function). + +Note that classes are callable, as are instances of classes with a +__call__() method. +[clinic start generated code]*/ static PyObject * -builtin_callable(PyObject *self, PyObject *v) +builtin_callable(PyModuleDef *module, PyObject *obj) +/*[clinic end generated code: output=f4df2ce92364b656 input=1423bab99cc41f58]*/ { - return PyBool_FromLong((long)PyCallable_Check(v)); + return PyBool_FromLong((long)PyCallable_Check(obj)); } -PyDoc_STRVAR(callable_doc, -"callable(object) -> bool\n\ -\n\ -Return whether the object is callable (i.e., some kind of function).\n\ -Note that classes are callable, as are instances of classes with a\n\ -__call__() method."); - typedef struct { PyObject_HEAD @@ -524,39 +561,41 @@ PyTypeObject PyFilter_Type = { }; -static PyObject * -builtin_format(PyObject *self, PyObject *args) -{ - PyObject *value; - PyObject *format_spec = NULL; +/*[clinic input] +format as builtin_format - if (!PyArg_ParseTuple(args, "O|U:format", &value, &format_spec)) - return NULL; + value: object + format_spec: unicode(c_default="NULL") = '' + / - return PyObject_Format(value, format_spec); -} +Return value.__format__(format_spec) -PyDoc_STRVAR(format_doc, -"format(value[, format_spec]) -> string\n\ -\n\ -Returns value.__format__(format_spec)\n\ -format_spec defaults to \"\""); +format_spec defaults to the empty string +[clinic start generated code]*/ static PyObject * -builtin_chr(PyObject *self, PyObject *args) +builtin_format_impl(PyModuleDef *module, PyObject *value, + PyObject *format_spec) +/*[clinic end generated code: output=4341fd78a5f01764 input=6325e751a1b29b86]*/ { - int x; + return PyObject_Format(value, format_spec); +} - if (!PyArg_ParseTuple(args, "i:chr", &x)) - return NULL; +/*[clinic input] +chr as builtin_chr - return PyUnicode_FromOrdinal(x); -} + i: int + / -PyDoc_STRVAR(chr_doc, -"chr(i) -> Unicode character\n\ -\n\ -Return a Unicode string of one character with ordinal i; 0 <= i <= 0x10ffff."); +Return a Unicode string of one character with ordinal i; 0 <= i <= 0x10ffff. +[clinic start generated code]*/ + +static PyObject * +builtin_chr_impl(PyModuleDef *module, int i) +/*[clinic end generated code: output=67fe4d87e690f373 input=3f604ef45a70750d]*/ +{ + return PyUnicode_FromOrdinal(i); +} static const char * @@ -599,8 +638,8 @@ source_as_string(PyObject *cmd, const char *funcname, const char *what, PyCompil return NULL; } - if (strlen(str) != size) { - PyErr_SetString(PyExc_TypeError, + if (strlen(str) != (size_t)size) { + PyErr_SetString(PyExc_ValueError, "source code string cannot contain null bytes"); Py_CLEAR(*cmd_copy); return NULL; @@ -608,35 +647,47 @@ source_as_string(PyObject *cmd, const char *funcname, const char *what, PyCompil return str; } +/*[clinic input] +compile as builtin_compile + + source: object + filename: object(converter="PyUnicode_FSDecoder") + mode: str + flags: int = 0 + dont_inherit: int(c_default="0") = False + optimize: int = -1 + +Compile source into a code object that can be executed by exec() or eval(). + +The source code may represent a Python module, statement or expression. +The filename will be used for run-time error messages. +The mode must be 'exec' to compile a module, 'single' to compile a +single (interactive) statement, or 'eval' to compile an expression. +The flags argument, if present, controls which future statements influence +the compilation of the code. +The dont_inherit argument, if true, stops the compilation inheriting +the effects of any future statements in effect in the code calling +compile; if absent or false these statements do influence the compilation, +in addition to any features explicitly specified. +[clinic start generated code]*/ + static PyObject * -builtin_compile(PyObject *self, PyObject *args, PyObject *kwds) +builtin_compile_impl(PyModuleDef *module, PyObject *source, + PyObject *filename, const char *mode, int flags, + int dont_inherit, int optimize) +/*[clinic end generated code: output=31881762c1bb90c4 input=9d53e8cfb3c86414]*/ { - PyObject *cmd_copy; + PyObject *source_copy; const char *str; - PyObject *filename; - char *startstr; - int mode = -1; - int dont_inherit = 0; - int supplied_flags = 0; - int optimize = -1; + int compile_mode = -1; int is_ast; PyCompilerFlags cf; - PyObject *cmd; - static char *kwlist[] = {"source", "filename", "mode", "flags", - "dont_inherit", "optimize", NULL}; int start[] = {Py_file_input, Py_eval_input, Py_single_input}; PyObject *result; - if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO&s|iii:compile", kwlist, - &cmd, - PyUnicode_FSDecoder, &filename, - &startstr, &supplied_flags, - &dont_inherit, &optimize)) - return NULL; - - cf.cf_flags = supplied_flags | PyCF_SOURCE_IS_UTF8; + cf.cf_flags = flags | PyCF_SOURCE_IS_UTF8; - if (supplied_flags & + if (flags & ~(PyCF_MASK | PyCF_MASK_OBSOLETE | PyCF_DONT_IMPLY_DEDENT | PyCF_ONLY_AST)) { PyErr_SetString(PyExc_ValueError, @@ -655,25 +706,25 @@ builtin_compile(PyObject *self, PyObject *args, PyObject *kwds) PyEval_MergeCompilerFlags(&cf); } - if (strcmp(startstr, "exec") == 0) - mode = 0; - else if (strcmp(startstr, "eval") == 0) - mode = 1; - else if (strcmp(startstr, "single") == 0) - mode = 2; + if (strcmp(mode, "exec") == 0) + compile_mode = 0; + else if (strcmp(mode, "eval") == 0) + compile_mode = 1; + else if (strcmp(mode, "single") == 0) + compile_mode = 2; else { PyErr_SetString(PyExc_ValueError, - "compile() arg 3 must be 'exec', 'eval' or 'single'"); + "compile() mode must be 'exec', 'eval' or 'single'"); goto error; } - is_ast = PyAST_Check(cmd); + is_ast = PyAST_Check(source); if (is_ast == -1) goto error; if (is_ast) { - if (supplied_flags & PyCF_ONLY_AST) { - Py_INCREF(cmd); - result = cmd; + if (flags & PyCF_ONLY_AST) { + Py_INCREF(source); + result = source; } else { PyArena *arena; @@ -682,7 +733,7 @@ builtin_compile(PyObject *self, PyObject *args, PyObject *kwds) arena = PyArena_New(); if (arena == NULL) goto error; - mod = PyAST_obj2mod(cmd, arena, mode); + mod = PyAST_obj2mod(source, arena, compile_mode); if (mod == NULL) { PyArena_Free(arena); goto error; @@ -698,12 +749,12 @@ builtin_compile(PyObject *self, PyObject *args, PyObject *kwds) goto finally; } - str = source_as_string(cmd, "compile", "string, bytes or AST", &cf, &cmd_copy); + str = source_as_string(source, "compile", "string, bytes or AST", &cf, &source_copy); if (str == NULL) goto error; - result = Py_CompileStringObject(str, filename, start[mode], &cf, optimize); - Py_XDECREF(cmd_copy); + result = Py_CompileStringObject(str, filename, start[compile_mode], &cf, optimize); + Py_XDECREF(source_copy); goto finally; error: @@ -713,21 +764,7 @@ finally: return result; } -PyDoc_STRVAR(compile_doc, -"compile(source, filename, mode[, flags[, dont_inherit]]) -> code object\n\ -\n\ -Compile the source (a Python module, statement or expression)\n\ -into a code object that can be executed by exec() or eval().\n\ -The filename will be used for run-time error messages.\n\ -The mode must be 'exec' to compile a module, 'single' to compile a\n\ -single (interactive) statement, or 'eval' to compile an expression.\n\ -The flags argument, if present, controls which future statements influence\n\ -the compilation of the code.\n\ -The dont_inherit argument, if non-zero, stops the compilation inheriting\n\ -the effects of any future statements in effect in the code calling\n\ -compile; if absent or zero these statements do influence the compilation,\n\ -in addition to any features explicitly specified."); - +/* AC: cannot convert yet, as needs PEP 457 group support in inspect */ static PyObject * builtin_dir(PyObject *self, PyObject *args) { @@ -752,32 +789,50 @@ PyDoc_STRVAR(dir_doc, " for any other object: its attributes, its class's attributes, and\n" " recursively the attributes of its class's base classes."); +/*[clinic input] +divmod as builtin_divmod + + x: object + y: object + / + +Return the tuple ((x-x%y)/y, x%y). Invariant: div*y + mod == x. +[clinic start generated code]*/ + static PyObject * -builtin_divmod(PyObject *self, PyObject *args) +builtin_divmod_impl(PyModuleDef *module, PyObject *x, PyObject *y) +/*[clinic end generated code: output=9ad0076120ebf9ac input=7fdb15f8a97a5fe7]*/ { - PyObject *v, *w; - - if (!PyArg_UnpackTuple(args, "divmod", 2, 2, &v, &w)) - return NULL; - return PyNumber_Divmod(v, w); + return PyNumber_Divmod(x, y); } -PyDoc_STRVAR(divmod_doc, -"divmod(x, y) -> (div, mod)\n\ -\n\ -Return the tuple ((x-x%y)/y, x%y). Invariant: div*y + mod == x."); +/*[clinic input] +eval as builtin_eval + + source: object + globals: object = None + locals: object = None + / + +Evaluate the given source in the context of globals and locals. + +The source may be a string representing a Python expression +or a code object as returned by compile(). +The globals must be a dictionary and locals can be any mapping, +defaulting to the current globals and locals. +If only globals is given, locals defaults to it. +[clinic start generated code]*/ static PyObject * -builtin_eval(PyObject *self, PyObject *args) +builtin_eval_impl(PyModuleDef *module, PyObject *source, PyObject *globals, + PyObject *locals) +/*[clinic end generated code: output=7284501fb7b4d666 input=11ee718a8640e527]*/ { - PyObject *cmd, *result, *cmd_copy; - PyObject *globals = Py_None, *locals = Py_None; + PyObject *result, *source_copy; const char *str; PyCompilerFlags cf; - if (!PyArg_UnpackTuple(args, "eval", 1, 3, &cmd, &globals, &locals)) - return NULL; if (locals != Py_None && !PyMapping_Check(locals)) { PyErr_SetString(PyExc_TypeError, "locals must be a mapping"); return NULL; @@ -812,17 +867,17 @@ builtin_eval(PyObject *self, PyObject *args) return NULL; } - if (PyCode_Check(cmd)) { - if (PyCode_GetNumFree((PyCodeObject *)cmd) > 0) { + if (PyCode_Check(source)) { + if (PyCode_GetNumFree((PyCodeObject *)source) > 0) { PyErr_SetString(PyExc_TypeError, "code object passed to eval() may not contain free variables"); return NULL; } - return PyEval_EvalCode(cmd, globals, locals); + return PyEval_EvalCode(source, globals, locals); } cf.cf_flags = PyCF_SOURCE_IS_UTF8; - str = source_as_string(cmd, "eval", "string, bytes or code", &cf, &cmd_copy); + str = source_as_string(source, "eval", "string, bytes or code", &cf, &source_copy); if (str == NULL) return NULL; @@ -831,28 +886,33 @@ builtin_eval(PyObject *self, PyObject *args) (void)PyEval_MergeCompilerFlags(&cf); result = PyRun_StringFlags(str, Py_eval_input, globals, locals, &cf); - Py_XDECREF(cmd_copy); + Py_XDECREF(source_copy); return result; } -PyDoc_STRVAR(eval_doc, -"eval(source[, globals[, locals]]) -> value\n\ -\n\ -Evaluate the source in the context of globals and locals.\n\ -The source may be a string representing a Python expression\n\ -or a code object as returned by compile().\n\ -The globals must be a dictionary and locals can be any mapping,\n\ -defaulting to the current globals and locals.\n\ -If only globals is given, locals defaults to it.\n"); +/*[clinic input] +exec as builtin_exec + + source: object + globals: object = None + locals: object = None + / + +Execute the given source in the context of globals and locals. + +The source may be a string representing one or more Python statements +or a code object as returned by compile(). +The globals must be a dictionary and locals can be any mapping, +defaulting to the current globals and locals. +If only globals is given, locals defaults to it. +[clinic start generated code]*/ static PyObject * -builtin_exec(PyObject *self, PyObject *args) +builtin_exec_impl(PyModuleDef *module, PyObject *source, PyObject *globals, + PyObject *locals) +/*[clinic end generated code: output=83d574ef9d5d0b46 input=01ca3e1c01692829]*/ { PyObject *v; - PyObject *prog, *globals = Py_None, *locals = Py_None; - - if (!PyArg_UnpackTuple(args, "exec", 1, 3, &prog, &globals, &locals)) - return NULL; if (globals == Py_None) { globals = PyEval_GetGlobals(); @@ -871,13 +931,13 @@ builtin_exec(PyObject *self, PyObject *args) locals = globals; if (!PyDict_Check(globals)) { - PyErr_Format(PyExc_TypeError, "exec() arg 2 must be a dict, not %.100s", + PyErr_Format(PyExc_TypeError, "exec() globals must be a dict, not %.100s", globals->ob_type->tp_name); return NULL; } if (!PyMapping_Check(locals)) { PyErr_Format(PyExc_TypeError, - "arg 3 must be a mapping or None, not %.100s", + "locals must be a mapping or None, not %.100s", locals->ob_type->tp_name); return NULL; } @@ -887,23 +947,23 @@ builtin_exec(PyObject *self, PyObject *args) return NULL; } - if (PyCode_Check(prog)) { - if (PyCode_GetNumFree((PyCodeObject *)prog) > 0) { + if (PyCode_Check(source)) { + if (PyCode_GetNumFree((PyCodeObject *)source) > 0) { PyErr_SetString(PyExc_TypeError, "code object passed to exec() may not " "contain free variables"); return NULL; } - v = PyEval_EvalCode(prog, globals, locals); + v = PyEval_EvalCode(source, globals, locals); } else { - PyObject *prog_copy; + PyObject *source_copy; const char *str; PyCompilerFlags cf; cf.cf_flags = PyCF_SOURCE_IS_UTF8; - str = source_as_string(prog, "exec", - "string, bytes or code", &cf, - &prog_copy); + str = source_as_string(source, "exec", + "string, bytes or code", &cf, + &source_copy); if (str == NULL) return NULL; if (PyEval_MergeCompilerFlags(&cf)) @@ -911,7 +971,7 @@ builtin_exec(PyObject *self, PyObject *args) locals, &cf); else v = PyRun_String(str, Py_file_input, globals, locals); - Py_XDECREF(prog_copy); + Py_XDECREF(source_copy); } if (v == NULL) return NULL; @@ -919,15 +979,8 @@ builtin_exec(PyObject *self, PyObject *args) Py_RETURN_NONE; } -PyDoc_STRVAR(exec_doc, -"exec(object[, globals[, locals]])\n\ -\n\ -Read and execute code from an object, which can be a string or a code\n\ -object.\n\ -The globals and locals are dictionaries, defaulting to the current\n\ -globals and locals. If only globals is given, locals defaults to it."); - +/* AC: cannot convert yet, as needs PEP 457 group support in inspect */ static PyObject * builtin_getattr(PyObject *self, PyObject *args) { @@ -961,8 +1014,18 @@ When a default argument is given, it is returned when the attribute doesn't\n\ exist; without it, an exception is raised in that case."); +/*[clinic input] +globals as builtin_globals + +Return the dictionary containing the current scope's global variables. + +NOTE: Updates to this dictionary *will* affect name lookups in the current +global scope and vice-versa. +[clinic start generated code]*/ + static PyObject * -builtin_globals(PyObject *self) +builtin_globals_impl(PyModuleDef *module) +/*[clinic end generated code: output=4958645e96dd8138 input=9327576f92bb48ba]*/ { PyObject *d; @@ -971,26 +1034,31 @@ builtin_globals(PyObject *self) return d; } -PyDoc_STRVAR(globals_doc, -"globals() -> dictionary\n\ -\n\ -Return the dictionary containing the current scope's global variables."); +/*[clinic input] +hasattr as builtin_hasattr + + obj: object + name: object + / + +Return whether the object has an attribute with the given name. + +This is done by calling getattr(obj, name) and catching AttributeError. +[clinic start generated code]*/ static PyObject * -builtin_hasattr(PyObject *self, PyObject *args) +builtin_hasattr_impl(PyModuleDef *module, PyObject *obj, PyObject *name) +/*[clinic end generated code: output=81154fdd63634696 input=0faec9787d979542]*/ { PyObject *v; - PyObject *name; - if (!PyArg_UnpackTuple(args, "hasattr", 2, 2, &v, &name)) - return NULL; if (!PyUnicode_Check(name)) { PyErr_SetString(PyExc_TypeError, "hasattr(): attribute name must be string"); return NULL; } - v = PyObject_GetAttr(v, name); + v = PyObject_GetAttr(obj, name); if (v == NULL) { if (PyErr_ExceptionMatches(PyExc_AttributeError)) { PyErr_Clear(); @@ -1002,25 +1070,31 @@ builtin_hasattr(PyObject *self, PyObject *args) Py_RETURN_TRUE; } -PyDoc_STRVAR(hasattr_doc, -"hasattr(object, name) -> bool\n\ -\n\ -Return whether the object has an attribute with the given name.\n\ -(This is done by calling getattr(object, name) and catching AttributeError.)"); +/* AC: gdb's integration with CPython relies on builtin_id having + * the *exact* parameter names of "self" and "v", so we ensure we + * preserve those name rather than using the AC defaults. + */ +/*[clinic input] +id as builtin_id + + self: self(type="PyModuleDef *") + obj as v: object + / + +Return the identity of an object. + +This is guaranteed to be unique among simultaneously existing objects. +(CPython uses the object's memory address.) +[clinic start generated code]*/ static PyObject * -builtin_id(PyObject *self, PyObject *v) +builtin_id(PyModuleDef *self, PyObject *v) +/*[clinic end generated code: output=0aa640785f697f65 input=5a534136419631f4]*/ { return PyLong_FromVoidPtr(v); } -PyDoc_STRVAR(id_doc, -"id(object) -> integer\n\ -\n\ -Return the identity of an object. This is guaranteed to be unique among\n\ -simultaneously existing objects. (Hint: it's the object's memory address.)"); - /* map object ************************************************************/ @@ -1193,6 +1267,8 @@ PyTypeObject PyMap_Type = { PyObject_GC_Del, /* tp_free */ }; + +/* AC: cannot convert yet, as needs PEP 457 group support in inspect */ static PyObject * builtin_next(PyObject *self, PyObject *args) { @@ -1234,83 +1310,100 @@ Return the next item from the iterator. If default is given and the iterator\n\ is exhausted, it is returned instead of raising StopIteration."); +/*[clinic input] +setattr as builtin_setattr + + obj: object + name: object + value: object + / + +Sets the named attribute on the given object to the specified value. + +setattr(x, 'y', v) is equivalent to ``x.y = v'' +[clinic start generated code]*/ + static PyObject * -builtin_setattr(PyObject *self, PyObject *args) +builtin_setattr_impl(PyModuleDef *module, PyObject *obj, PyObject *name, + PyObject *value) +/*[clinic end generated code: output=d881c655c0f7e34f input=bd2b7ca6875a1899]*/ { - PyObject *v; - PyObject *name; - PyObject *value; - - if (!PyArg_UnpackTuple(args, "setattr", 3, 3, &v, &name, &value)) - return NULL; - if (PyObject_SetAttr(v, name, value) != 0) + if (PyObject_SetAttr(obj, name, value) != 0) return NULL; Py_INCREF(Py_None); return Py_None; } -PyDoc_STRVAR(setattr_doc, -"setattr(object, name, value)\n\ -\n\ -Set a named attribute on an object; setattr(x, 'y', v) is equivalent to\n\ -``x.y = v''."); +/*[clinic input] +delattr as builtin_delattr + + obj: object + name: object + / + +Deletes the named attribute from the given object. + +delattr(x, 'y') is equivalent to ``del x.y'' +[clinic start generated code]*/ static PyObject * -builtin_delattr(PyObject *self, PyObject *args) +builtin_delattr_impl(PyModuleDef *module, PyObject *obj, PyObject *name) +/*[clinic end generated code: output=ef653e698a0b4187 input=db16685d6b4b9410]*/ { - PyObject *v; - PyObject *name; - - if (!PyArg_UnpackTuple(args, "delattr", 2, 2, &v, &name)) - return NULL; - if (PyObject_SetAttr(v, name, (PyObject *)NULL) != 0) + if (PyObject_SetAttr(obj, name, (PyObject *)NULL) != 0) return NULL; Py_INCREF(Py_None); return Py_None; } -PyDoc_STRVAR(delattr_doc, -"delattr(object, name)\n\ -\n\ -Delete a named attribute on an object; delattr(x, 'y') is equivalent to\n\ -``del x.y''."); +/*[clinic input] +hash as builtin_hash + + obj: object + / + +Return the hash value for the given object. + +Two objects that compare equal must also have the same hash value, but the +reverse is not necessarily true. +[clinic start generated code]*/ static PyObject * -builtin_hash(PyObject *self, PyObject *v) +builtin_hash(PyModuleDef *module, PyObject *obj) +/*[clinic end generated code: output=1f32ff154c1f751a input=58c48be822bf9c54]*/ { Py_hash_t x; - x = PyObject_Hash(v); + x = PyObject_Hash(obj); if (x == -1) return NULL; return PyLong_FromSsize_t(x); } -PyDoc_STRVAR(hash_doc, -"hash(object) -> integer\n\ -\n\ -Return a hash value for the object. Two objects with the same value have\n\ -the same hash value. The reverse is not necessarily true, but likely."); +/*[clinic input] +hex as builtin_hex + + number: object + / + +Return the hexadecimal representation of an integer. + + >>> hex(12648430) + '0xc0ffee' +[clinic start generated code]*/ static PyObject * -builtin_hex(PyObject *self, PyObject *v) +builtin_hex(PyModuleDef *module, PyObject *number) +/*[clinic end generated code: output=618489ce3cbc5858 input=e645aff5fc7d540e]*/ { - return PyNumber_ToBase(v, 16); + return PyNumber_ToBase(number, 16); } -PyDoc_STRVAR(hex_doc, -"hex(number) -> string\n\ -\n\ -Return the hexadecimal representation of an integer.\n\ -\n\ - >>> hex(3735928559)\n\ - '0xdeadbeef'\n\ -"); - +/* AC: cannot convert yet, as needs PEP 457 group support in inspect */ static PyObject * builtin_iter(PyObject *self, PyObject *args) { @@ -1337,25 +1430,41 @@ supply its own iterator, or be a sequence.\n\ In the second form, the callable is called until it returns the sentinel."); +/*[clinic input] +len as builtin_len + + obj: object + / + +Return the number of items in a container. +[clinic start generated code]*/ + static PyObject * -builtin_len(PyObject *self, PyObject *v) +builtin_len(PyModuleDef *module, PyObject *obj) +/*[clinic end generated code: output=8e5837b6f81d915b input=bc55598da9e9c9b5]*/ { Py_ssize_t res; - res = PyObject_Size(v); + res = PyObject_Size(obj); if (res < 0 && PyErr_Occurred()) return NULL; return PyLong_FromSsize_t(res); } -PyDoc_STRVAR(len_doc, -"len(object)\n\ -\n\ -Return the number of items of a sequence or collection."); +/*[clinic input] +locals as builtin_locals + +Return a dictionary containing the current scope's local variables. + +NOTE: Whether or not updates to this dictionary will affect name lookups in +the local scope and vice-versa is *implementation dependent* and not +covered by any backwards compatibility guarantees. +[clinic start generated code]*/ static PyObject * -builtin_locals(PyObject *self) +builtin_locals_impl(PyModuleDef *module) +/*[clinic end generated code: output=8b5a41f12e19d13a input=7874018d478d5c4b]*/ { PyObject *d; @@ -1364,11 +1473,6 @@ builtin_locals(PyObject *self) return d; } -PyDoc_STRVAR(locals_doc, -"locals() -> dictionary\n\ -\n\ -Update and return a dictionary containing the current scope's local variables."); - static PyObject * min_max(PyObject *args, PyObject *kwds, int op) @@ -1471,6 +1575,7 @@ Fail_it: return NULL; } +/* AC: cannot convert yet, waiting for *args support */ static PyObject * builtin_min(PyObject *self, PyObject *args, PyObject *kwds) { @@ -1487,6 +1592,7 @@ the provided iterable is empty.\n\ With two or more arguments, return the smallest argument."); +/* AC: cannot convert yet, waiting for *args support */ static PyObject * builtin_max(PyObject *self, PyObject *args, PyObject *kwds) { @@ -1503,56 +1609,70 @@ the provided iterable is empty.\n\ With two or more arguments, return the largest argument."); +/*[clinic input] +oct as builtin_oct + + number: object + / + +Return the octal representation of an integer. + + >>> oct(342391) + '0o1234567' +[clinic start generated code]*/ + static PyObject * -builtin_oct(PyObject *self, PyObject *v) +builtin_oct(PyModuleDef *module, PyObject *number) +/*[clinic end generated code: output=18f701bc6d8f804a input=ad6b274af4016c72]*/ { - return PyNumber_ToBase(v, 8); + return PyNumber_ToBase(number, 8); } -PyDoc_STRVAR(oct_doc, -"oct(number) -> string\n\ -\n\ -Return the octal representation of an integer.\n\ -\n\ - >>> oct(342391)\n\ - '0o1234567'\n\ -"); +/*[clinic input] +ord as builtin_ord + + c: object + / + +Return the Unicode code point for a one-character string. +[clinic start generated code]*/ static PyObject * -builtin_ord(PyObject *self, PyObject* obj) +builtin_ord(PyModuleDef *module, PyObject *c) +/*[clinic end generated code: output=04fd27272d9462f6 input=3064e5d6203ad012]*/ { long ord; Py_ssize_t size; - if (PyBytes_Check(obj)) { - size = PyBytes_GET_SIZE(obj); + if (PyBytes_Check(c)) { + size = PyBytes_GET_SIZE(c); if (size == 1) { - ord = (long)((unsigned char)*PyBytes_AS_STRING(obj)); + ord = (long)((unsigned char)*PyBytes_AS_STRING(c)); return PyLong_FromLong(ord); } } - else if (PyUnicode_Check(obj)) { - if (PyUnicode_READY(obj) == -1) + else if (PyUnicode_Check(c)) { + if (PyUnicode_READY(c) == -1) return NULL; - size = PyUnicode_GET_LENGTH(obj); + size = PyUnicode_GET_LENGTH(c); if (size == 1) { - ord = (long)PyUnicode_READ_CHAR(obj, 0); + ord = (long)PyUnicode_READ_CHAR(c, 0); return PyLong_FromLong(ord); } } - else if (PyByteArray_Check(obj)) { + else if (PyByteArray_Check(c)) { /* XXX Hopefully this is temporary */ - size = PyByteArray_GET_SIZE(obj); + size = PyByteArray_GET_SIZE(c); if (size == 1) { - ord = (long)((unsigned char)*PyByteArray_AS_STRING(obj)); + ord = (long)((unsigned char)*PyByteArray_AS_STRING(c)); return PyLong_FromLong(ord); } } else { PyErr_Format(PyExc_TypeError, "ord() expected string of length 1, but " \ - "%.200s found", obj->ob_type->tp_name); + "%.200s found", c->ob_type->tp_name); return NULL; } @@ -1563,31 +1683,30 @@ builtin_ord(PyObject *self, PyObject* obj) return NULL; } -PyDoc_VAR(ord_doc) = PyDoc_STR( -"ord(c) -> integer\n\ -\n\ -Return the integer ordinal of a one-character string." -); +/*[clinic input] +pow as builtin_pow -static PyObject * -builtin_pow(PyObject *self, PyObject *args) -{ - PyObject *v, *w, *z = Py_None; + x: object + y: object + z: object = None + / - if (!PyArg_UnpackTuple(args, "pow", 2, 3, &v, &w, &z)) - return NULL; - return PyNumber_Power(v, w, z); -} +Equivalent to x**y (with two arguments) or x**y % z (with three arguments) -PyDoc_STRVAR(pow_doc, -"pow(x, y[, z]) -> number\n\ -\n\ -With two arguments, equivalent to x**y. With three arguments,\n\ -equivalent to (x**y) % z, but may be more efficient (e.g. for ints)."); +Some types, such as ints, are able to use a more efficient algorithm when +invoked using the three argument form. +[clinic start generated code]*/ +static PyObject * +builtin_pow_impl(PyModuleDef *module, PyObject *x, PyObject *y, PyObject *z) +/*[clinic end generated code: output=1fba268adba9b45f input=653d57d38d41fc07]*/ +{ + return PyNumber_Power(x, y, z); +} +/* AC: cannot convert yet, waiting for *args support */ static PyObject * builtin_print(PyObject *self, PyObject *args, PyObject *kwds) { @@ -1683,10 +1802,25 @@ end: string appended after the last value, default a newline.\n\ flush: whether to forcibly flush the stream."); +/*[clinic input] +input as builtin_input + + prompt: object(c_default="NULL") = None + / + +Read a string from standard input. The trailing newline is stripped. + +The prompt string, if given, is printed to standard output without a +trailing newline before reading input. + +If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError. +On *nix systems, readline is used if available. +[clinic start generated code]*/ + static PyObject * -builtin_input(PyObject *self, PyObject *args) +builtin_input_impl(PyModuleDef *module, PyObject *prompt) +/*[clinic end generated code: output=b77731f59e1515c4 input=5e8bb70c2908fe3c]*/ { - PyObject *promptarg = NULL; PyObject *fin = _PySys_GetObjectId(&PyId_stdin); PyObject *fout = _PySys_GetObjectId(&PyId_stdout); PyObject *ferr = _PySys_GetObjectId(&PyId_stderr); @@ -1694,10 +1828,6 @@ builtin_input(PyObject *self, PyObject *args) long fd; int tty; - /* Parse arguments */ - if (!PyArg_UnpackTuple(args, "input", 0, 1, &promptarg)) - return NULL; - /* Check that stdin/out/err are intact */ if (fin == NULL || fin == Py_None) { PyErr_SetString(PyExc_RuntimeError, @@ -1755,7 +1885,7 @@ builtin_input(PyObject *self, PyObject *args) /* If we're interactive, use (GNU) readline */ if (tty) { PyObject *po = NULL; - char *prompt; + char *promptstr; char *s = NULL; PyObject *stdin_encoding = NULL, *stdin_errors = NULL; PyObject *stdout_encoding = NULL, *stdout_errors = NULL; @@ -1778,7 +1908,7 @@ builtin_input(PyObject *self, PyObject *args) PyErr_Clear(); else Py_DECREF(tmp); - if (promptarg != NULL) { + if (prompt != NULL) { /* We have a prompt, encode it as stdout would */ char *stdout_encoding_str, *stdout_errors_str; PyObject *stringpo; @@ -1790,7 +1920,7 @@ builtin_input(PyObject *self, PyObject *args) stdout_errors_str = _PyUnicode_AsString(stdout_errors); if (!stdout_encoding_str || !stdout_errors_str) goto _readline_errors; - stringpo = PyObject_Str(promptarg); + stringpo = PyObject_Str(prompt); if (stringpo == NULL) goto _readline_errors; po = PyUnicode_AsEncodedString(stringpo, @@ -1800,15 +1930,15 @@ builtin_input(PyObject *self, PyObject *args) Py_CLEAR(stringpo); if (po == NULL) goto _readline_errors; - prompt = PyBytes_AsString(po); - if (prompt == NULL) + promptstr = PyBytes_AsString(po); + if (promptstr == NULL) goto _readline_errors; } else { po = NULL; - prompt = ""; + promptstr = ""; } - s = PyOS_Readline(stdin, stdout, prompt); + s = PyOS_Readline(stdin, stdout, promptstr); if (s == NULL) { PyErr_CheckSignals(); if (!PyErr_Occurred()) @@ -1850,8 +1980,8 @@ builtin_input(PyObject *self, PyObject *args) } /* Fallback if we're not interactive */ - if (promptarg != NULL) { - if (PyFile_WriteObject(promptarg, fout, Py_PRINT_RAW) != 0) + if (prompt != NULL) { + if (PyFile_WriteObject(prompt, fout, Py_PRINT_RAW) != 0) return NULL; } tmp = _PyObject_CallMethodId(fout, &PyId_flush, ""); @@ -1862,28 +1992,29 @@ builtin_input(PyObject *self, PyObject *args) return PyFile_GetLine(fin, -1); } -PyDoc_STRVAR(input_doc, -"input([prompt]) -> string\n\ -\n\ -Read a string from standard input. The trailing newline is stripped.\n\ -If the user hits EOF (Unix: Ctl-D, Windows: Ctl-Z+Return), raise EOFError.\n\ -On Unix, GNU readline is used if enabled. The prompt string, if given,\n\ -is printed without a trailing newline before reading."); +/*[clinic input] +repr as builtin_repr + + obj: object + / + +Return the canonical string representation of the object. + +For many object types, including most builtins, eval(repr(obj)) == obj. +[clinic start generated code]*/ static PyObject * -builtin_repr(PyObject *self, PyObject *v) +builtin_repr(PyModuleDef *module, PyObject *obj) +/*[clinic end generated code: output=dc41784fa4341834 input=1c9e6d66d3e3be04]*/ { - return PyObject_Repr(v); + return PyObject_Repr(obj); } -PyDoc_STRVAR(repr_doc, -"repr(object) -> string\n\ -\n\ -Return the canonical string representation of the object.\n\ -For most object types, eval(repr(object)) == object."); - +/* AC: cannot convert yet, as needs PEP 457 group support in inspect + * or a semantic change to accept None for "ndigits" + */ static PyObject * builtin_round(PyObject *self, PyObject *args, PyObject *kwds) { @@ -1925,6 +2056,35 @@ This returns an int when called with one argument, otherwise the\n\ same type as the number. ndigits may be negative."); +/*AC: we need to keep the kwds dict intact to easily call into the + * list.sort method, which isn't currently supported in AC. So we just use + * the initially generated signature with a custom implementation. + */ +/* [disabled clinic input] +sorted as builtin_sorted + + iterable as seq: object + key as keyfunc: object = None + reverse: object = False + +Return a new list containing all items from the iterable in ascending order. + +A custom key function can be supplied to customise the sort order, and the +reverse flag can be set to request the result in descending order. +[end disabled clinic input]*/ + +PyDoc_STRVAR(builtin_sorted__doc__, +"sorted($module, iterable, key=None, reverse=False)\n" +"--\n" +"\n" +"Return a new list containing all items from the iterable in ascending order.\n" +"\n" +"A custom key function can be supplied to customise the sort order, and the\n" +"reverse flag can be set to request the result in descending order."); + +#define BUILTIN_SORTED_METHODDEF \ + {"sorted", (PyCFunction)builtin_sorted, METH_VARARGS|METH_KEYWORDS, builtin_sorted__doc__}, + static PyObject * builtin_sorted(PyObject *self, PyObject *args, PyObject *kwds) { @@ -1966,9 +2126,8 @@ builtin_sorted(PyObject *self, PyObject *args, PyObject *kwds) return newlist; } -PyDoc_STRVAR(sorted_doc, -"sorted(iterable, key=None, reverse=False) --> new sorted list"); +/* AC: cannot convert yet, as needs PEP 457 group support in inspect */ static PyObject * builtin_vars(PyObject *self, PyObject *args) { @@ -2000,17 +2159,29 @@ PyDoc_STRVAR(vars_doc, Without arguments, equivalent to locals().\n\ With an argument, equivalent to object.__dict__."); -static PyObject* -builtin_sum(PyObject *self, PyObject *args) + +/*[clinic input] +sum as builtin_sum + + iterable: object + start: object(c_default="NULL") = 0 + / + +Return the sum of a 'start' value (default: 0) plus an iterable of numbers + +When the iterable is empty, return the start value. +This function is intended specifically for use with numeric values and may +reject non-numeric types. +[clinic start generated code]*/ + +static PyObject * +builtin_sum_impl(PyModuleDef *module, PyObject *iterable, PyObject *start) +/*[clinic end generated code: output=33655b248b21d581 input=3b5b7a9d7611c73a]*/ { - PyObject *seq; - PyObject *result = NULL; + PyObject *result = start; PyObject *temp, *item, *iter; - if (!PyArg_UnpackTuple(args, "sum", 1, 2, &seq, &result)) - return NULL; - - iter = PyObject_GetIter(seq); + iter = PyObject_GetIter(iterable); if (iter == NULL) return NULL; @@ -2040,7 +2211,6 @@ builtin_sum(PyObject *self, PyObject *args) Py_DECREF(iter); return NULL; } - Py_INCREF(result); } @@ -2166,62 +2336,62 @@ builtin_sum(PyObject *self, PyObject *args) return result; } -PyDoc_STRVAR(sum_doc, -"sum(iterable[, start]) -> value\n\ -\n\ -Return the sum of an iterable of numbers (NOT strings) plus the value\n\ -of parameter 'start' (which defaults to 0). When the iterable is\n\ -empty, return start."); +/*[clinic input] +isinstance as builtin_isinstance + + obj: object + class_or_tuple: object + / + +Return whether an object is an instance of a class or of a subclass thereof. + +A tuple, as in ``isinstance(x, (A, B, ...))``, may be given as the target to +check against. This is equivalent to ``isinstance(x, A) or isinstance(x, B) +or ...`` etc. +[clinic start generated code]*/ static PyObject * -builtin_isinstance(PyObject *self, PyObject *args) +builtin_isinstance_impl(PyModuleDef *module, PyObject *obj, + PyObject *class_or_tuple) +/*[clinic end generated code: output=f960b7c12dbbeda0 input=ffa743db1daf7549]*/ { - PyObject *inst; - PyObject *cls; int retval; - if (!PyArg_UnpackTuple(args, "isinstance", 2, 2, &inst, &cls)) - return NULL; - - retval = PyObject_IsInstance(inst, cls); + retval = PyObject_IsInstance(obj, class_or_tuple); if (retval < 0) return NULL; return PyBool_FromLong(retval); } -PyDoc_STRVAR(isinstance_doc, -"isinstance(object, class-or-type-or-tuple) -> bool\n\ -\n\ -Return whether an object is an instance of a class or of a subclass thereof.\n\ -With a type as second argument, return whether that is the object's type.\n\ -The form using a tuple, isinstance(x, (A, B, ...)), is a shortcut for\n\ -isinstance(x, A) or isinstance(x, B) or ... (etc.)."); +/*[clinic input] +issubclass as builtin_issubclass + + cls: object + class_or_tuple: object + / + +Return whether 'cls' is a derived from another class or is the same class. + +A tuple, as in ``issubclass(x, (A, B, ...))``, may be given as the target to +check against. This is equivalent to ``issubclass(x, A) or issubclass(x, B) +or ...`` etc. +[clinic start generated code]*/ static PyObject * -builtin_issubclass(PyObject *self, PyObject *args) +builtin_issubclass_impl(PyModuleDef *module, PyObject *cls, + PyObject *class_or_tuple) +/*[clinic end generated code: output=8b012a151940bbf2 input=af5f35e9ceaddaf6]*/ { - PyObject *derived; - PyObject *cls; int retval; - if (!PyArg_UnpackTuple(args, "issubclass", 2, 2, &derived, &cls)) - return NULL; - - retval = PyObject_IsSubclass(derived, cls); + retval = PyObject_IsSubclass(cls, class_or_tuple); if (retval < 0) return NULL; return PyBool_FromLong(retval); } -PyDoc_STRVAR(issubclass_doc, -"issubclass(C, B) -> bool\n\ -\n\ -Return whether class C is a subclass (i.e., a derived class) of class B.\n\ -When using a tuple as the second argument issubclass(X, (A, B, ...)),\n\ -is a shortcut for issubclass(X, A) or issubclass(X, B) or ... (etc.)."); - typedef struct { PyObject_HEAD @@ -2416,44 +2586,44 @@ static PyMethodDef builtin_methods[] = { {"__build_class__", (PyCFunction)builtin___build_class__, METH_VARARGS | METH_KEYWORDS, build_class_doc}, {"__import__", (PyCFunction)builtin___import__, METH_VARARGS | METH_KEYWORDS, import_doc}, - {"abs", builtin_abs, METH_O, abs_doc}, - {"all", builtin_all, METH_O, all_doc}, - {"any", builtin_any, METH_O, any_doc}, - {"ascii", builtin_ascii, METH_O, ascii_doc}, - {"bin", builtin_bin, METH_O, bin_doc}, - {"callable", builtin_callable, METH_O, callable_doc}, - {"chr", builtin_chr, METH_VARARGS, chr_doc}, - {"compile", (PyCFunction)builtin_compile, METH_VARARGS | METH_KEYWORDS, compile_doc}, - {"delattr", builtin_delattr, METH_VARARGS, delattr_doc}, + BUILTIN_ABS_METHODDEF + BUILTIN_ALL_METHODDEF + BUILTIN_ANY_METHODDEF + BUILTIN_ASCII_METHODDEF + BUILTIN_BIN_METHODDEF + BUILTIN_CALLABLE_METHODDEF + BUILTIN_CHR_METHODDEF + BUILTIN_COMPILE_METHODDEF + BUILTIN_DELATTR_METHODDEF {"dir", builtin_dir, METH_VARARGS, dir_doc}, - {"divmod", builtin_divmod, METH_VARARGS, divmod_doc}, - {"eval", builtin_eval, METH_VARARGS, eval_doc}, - {"exec", builtin_exec, METH_VARARGS, exec_doc}, - {"format", builtin_format, METH_VARARGS, format_doc}, + BUILTIN_DIVMOD_METHODDEF + BUILTIN_EVAL_METHODDEF + BUILTIN_EXEC_METHODDEF + BUILTIN_FORMAT_METHODDEF {"getattr", builtin_getattr, METH_VARARGS, getattr_doc}, - {"globals", (PyCFunction)builtin_globals, METH_NOARGS, globals_doc}, - {"hasattr", builtin_hasattr, METH_VARARGS, hasattr_doc}, - {"hash", builtin_hash, METH_O, hash_doc}, - {"hex", builtin_hex, METH_O, hex_doc}, - {"id", builtin_id, METH_O, id_doc}, - {"input", builtin_input, METH_VARARGS, input_doc}, - {"isinstance", builtin_isinstance, METH_VARARGS, isinstance_doc}, - {"issubclass", builtin_issubclass, METH_VARARGS, issubclass_doc}, + BUILTIN_GLOBALS_METHODDEF + BUILTIN_HASATTR_METHODDEF + BUILTIN_HASH_METHODDEF + BUILTIN_HEX_METHODDEF + BUILTIN_ID_METHODDEF + BUILTIN_INPUT_METHODDEF + BUILTIN_ISINSTANCE_METHODDEF + BUILTIN_ISSUBCLASS_METHODDEF {"iter", builtin_iter, METH_VARARGS, iter_doc}, - {"len", builtin_len, METH_O, len_doc}, - {"locals", (PyCFunction)builtin_locals, METH_NOARGS, locals_doc}, + BUILTIN_LEN_METHODDEF + BUILTIN_LOCALS_METHODDEF {"max", (PyCFunction)builtin_max, METH_VARARGS | METH_KEYWORDS, max_doc}, {"min", (PyCFunction)builtin_min, METH_VARARGS | METH_KEYWORDS, min_doc}, {"next", (PyCFunction)builtin_next, METH_VARARGS, next_doc}, - {"oct", builtin_oct, METH_O, oct_doc}, - {"ord", builtin_ord, METH_O, ord_doc}, - {"pow", builtin_pow, METH_VARARGS, pow_doc}, + BUILTIN_OCT_METHODDEF + BUILTIN_ORD_METHODDEF + BUILTIN_POW_METHODDEF {"print", (PyCFunction)builtin_print, METH_VARARGS | METH_KEYWORDS, print_doc}, - {"repr", builtin_repr, METH_O, repr_doc}, + BUILTIN_REPR_METHODDEF {"round", (PyCFunction)builtin_round, METH_VARARGS | METH_KEYWORDS, round_doc}, - {"setattr", builtin_setattr, METH_VARARGS, setattr_doc}, - {"sorted", (PyCFunction)builtin_sorted, METH_VARARGS | METH_KEYWORDS, sorted_doc}, - {"sum", builtin_sum, METH_VARARGS, sum_doc}, + BUILTIN_SETATTR_METHODDEF + BUILTIN_SORTED_METHODDEF + BUILTIN_SUM_METHODDEF {"vars", builtin_vars, METH_VARARGS, vars_doc}, {NULL, NULL}, }; diff --git a/Python/ceval.c b/Python/ceval.c index 7a0cb7f04a..beabfebc1c 100644 --- a/Python/ceval.c +++ b/Python/ceval.c @@ -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 <ctype.h> @@ -735,7 +737,7 @@ _Py_CheckRecursiveCall(const char *where) if (tstate->recursion_depth > recursion_limit) { --tstate->recursion_depth; tstate->overflowed = 1; - PyErr_Format(PyExc_RuntimeError, + PyErr_Format(PyExc_RecursionError, "maximum recursion depth exceeded%s", where); return -1; @@ -1189,7 +1191,7 @@ PyEval_EvalFrameEx(PyFrameObject *f, int throwflag) f->f_stacktop = NULL; /* remains NULL unless yield suspends frame */ f->f_executing = 1; - if (co->co_flags & CO_GENERATOR) { + if (co->co_flags & (CO_GENERATOR | CO_COROUTINE)) { if (!throwflag && f->f_exc_type != NULL && f->f_exc_type != Py_None) { /* We were in an except handler when we left, restore the exception state which was put aside @@ -1504,6 +1506,18 @@ PyEval_EvalFrameEx(PyFrameObject *f, int throwflag) DISPATCH(); } + TARGET(BINARY_MATRIX_MULTIPLY) { + PyObject *right = POP(); + PyObject *left = TOP(); + PyObject *res = PyNumber_MatrixMultiply(left, right); + Py_DECREF(left); + Py_DECREF(right); + SET_TOP(res); + if (res == NULL) + goto error; + DISPATCH(); + } + TARGET(BINARY_TRUE_DIVIDE) { PyObject *divisor = POP(); PyObject *dividend = TOP(); @@ -1694,6 +1708,18 @@ PyEval_EvalFrameEx(PyFrameObject *f, int throwflag) DISPATCH(); } + TARGET(INPLACE_MATRIX_MULTIPLY) { + PyObject *right = POP(); + PyObject *left = TOP(); + PyObject *res = PyNumber_InPlaceMatrixMultiply(left, right); + Py_DECREF(left); + Py_DECREF(right); + SET_TOP(res); + if (res == NULL) + goto error; + DISPATCH(); + } + TARGET(INPLACE_TRUE_DIVIDE) { PyObject *divisor = POP(); PyObject *dividend = TOP(); @@ -1900,11 +1926,115 @@ PyEval_EvalFrameEx(PyFrameObject *f, int throwflag) goto fast_block_end; } + TARGET(GET_AITER) { + unaryfunc getter = NULL; + PyObject *iter = NULL; + PyObject *awaitable = NULL; + PyObject *obj = TOP(); + PyTypeObject *type = Py_TYPE(obj); + + if (type->tp_as_async != NULL) + getter = type->tp_as_async->am_aiter; + + if (getter != NULL) { + iter = (*getter)(obj); + Py_DECREF(obj); + if (iter == NULL) { + SET_TOP(NULL); + goto error; + } + } + else { + SET_TOP(NULL); + PyErr_Format( + PyExc_TypeError, + "'async for' requires an object with " + "__aiter__ method, got %.100s", + type->tp_name); + Py_DECREF(obj); + goto error; + } + + awaitable = _PyCoro_GetAwaitableIter(iter); + if (awaitable == NULL) { + SET_TOP(NULL); + PyErr_Format( + PyExc_TypeError, + "'async for' received an invalid object " + "from __aiter__: %.100s", + Py_TYPE(iter)->tp_name); + + Py_DECREF(iter); + goto error; + } else + Py_DECREF(iter); + + SET_TOP(awaitable); + DISPATCH(); + } + + TARGET(GET_ANEXT) { + unaryfunc getter = NULL; + PyObject *next_iter = NULL; + PyObject *awaitable = NULL; + PyObject *aiter = TOP(); + PyTypeObject *type = Py_TYPE(aiter); + + if (type->tp_as_async != NULL) + getter = type->tp_as_async->am_anext; + + if (getter != NULL) { + next_iter = (*getter)(aiter); + if (next_iter == NULL) { + goto error; + } + } + else { + PyErr_Format( + PyExc_TypeError, + "'async for' requires an iterator with " + "__anext__ method, got %.100s", + type->tp_name); + goto error; + } + + awaitable = _PyCoro_GetAwaitableIter(next_iter); + if (awaitable == NULL) { + PyErr_Format( + PyExc_TypeError, + "'async for' received an invalid object " + "from __anext__: %.100s", + Py_TYPE(next_iter)->tp_name); + + Py_DECREF(next_iter); + goto error; + } else + Py_DECREF(next_iter); + + PUSH(awaitable); + DISPATCH(); + } + + TARGET(GET_AWAITABLE) { + PyObject *iterable = TOP(); + PyObject *iter = _PyCoro_GetAwaitableIter(iterable); + + Py_DECREF(iterable); + + SET_TOP(iter); /* Even if it's NULL */ + + if (iter == NULL) { + goto error; + } + + DISPATCH(); + } + TARGET(YIELD_FROM) { PyObject *v = POP(); PyObject *reciever = TOP(); int err; - if (PyGen_CheckExact(reciever)) { + if (PyGen_CheckExact(reciever) || PyCoro_CheckExact(reciever)) { retval = _PyGen_Send((PyGenObject *)reciever, v); } else { _Py_IDENTIFIER(send); @@ -2233,6 +2363,10 @@ PyEval_EvalFrameEx(PyFrameObject *f, int throwflag) /* Slow-path if globals or builtins is not a dict */ v = PyObject_GetItem(f->f_globals, name); if (v == NULL) { + if (!PyErr_ExceptionMatches(PyExc_KeyError)) + goto error; + PyErr_Clear(); + v = PyObject_GetItem(f->f_builtins, name); if (v == NULL) { if (PyErr_ExceptionMatches(PyExc_KeyError)) @@ -2355,6 +2489,43 @@ PyEval_EvalFrameEx(PyFrameObject *f, int throwflag) DISPATCH(); } + TARGET_WITH_IMPL(BUILD_TUPLE_UNPACK, _build_list_unpack) + TARGET(BUILD_LIST_UNPACK) + _build_list_unpack: { + int convert_to_tuple = opcode == BUILD_TUPLE_UNPACK; + int i; + PyObject *sum = PyList_New(0); + PyObject *return_value; + 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); + } + + if (convert_to_tuple) { + return_value = PyList_AsTuple(sum); + Py_DECREF(sum); + if (return_value == NULL) + goto error; + } + else { + return_value = sum; + } + + while (oparg--) + Py_DECREF(POP()); + PUSH(return_value); + DISPATCH(); + } + TARGET(BUILD_SET) { PyObject *set = PySet_New(NULL); int err = 0; @@ -2374,26 +2545,127 @@ PyEval_EvalFrameEx(PyFrameObject *f, int throwflag) 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) { + int i; PyObject *map = _PyDict_NewPresized((Py_ssize_t)oparg); if (map == NULL) goto error; + for (i = oparg; i > 0; i--) { + int err; + PyObject *key = PEEK(2*i); + PyObject *value = PEEK(2*i - 1); + err = PyDict_SetItem(map, key, value); + if (err != 0) { + Py_DECREF(map); + goto error; + } + } + + while (oparg--) { + Py_DECREF(POP()); + Py_DECREF(POP()); + } PUSH(map); DISPATCH(); } - TARGET(STORE_MAP) { - PyObject *key = TOP(); - PyObject *value = SECOND(); - PyObject *map = THIRD(); - int err; - STACKADJ(-2); - assert(PyDict_CheckExact(map)); - err = PyDict_SetItem(map, key, value); - Py_DECREF(value); - Py_DECREF(key); - if (err != 0) + 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(); } @@ -2655,6 +2927,34 @@ PyEval_EvalFrameEx(PyFrameObject *f, int throwflag) DISPATCH(); } + TARGET(GET_YIELD_FROM_ITER) { + /* before: [obj]; after [getiter(obj)] */ + PyObject *iterable = TOP(); + PyObject *iter; + if (PyCoro_CheckExact(iterable)) { + /* `iterable` is a coroutine */ + if (!(co->co_flags & (CO_COROUTINE | CO_ITERABLE_COROUTINE))) { + /* and it is used in a 'yield from' expression of a + regular generator. */ + Py_DECREF(iterable); + SET_TOP(NULL); + PyErr_SetString(PyExc_TypeError, + "cannot 'yield from' a coroutine object " + "in a non-coroutine generator"); + goto error; + } + } + else if (!PyGen_CheckExact(iterable)) { + /* `iterable` is not a generator. */ + iter = PyObject_GetIter(iterable); + Py_DECREF(iterable); + SET_TOP(iter); + if (iter == NULL) + goto error; + } + DISPATCH(); + } + PREDICTED_WITH_ARG(FOR_ITER); TARGET(FOR_ITER) { /* before: [iter]; after: [iter, iter()] *or* [] */ @@ -2707,6 +3007,39 @@ PyEval_EvalFrameEx(PyFrameObject *f, int throwflag) DISPATCH(); } + TARGET(BEFORE_ASYNC_WITH) { + _Py_IDENTIFIER(__aexit__); + _Py_IDENTIFIER(__aenter__); + + PyObject *mgr = TOP(); + PyObject *exit = special_lookup(mgr, &PyId___aexit__), + *enter; + PyObject *res; + if (exit == NULL) + goto error; + SET_TOP(exit); + enter = special_lookup(mgr, &PyId___aenter__); + Py_DECREF(mgr); + if (enter == NULL) + goto error; + res = PyObject_CallFunctionObjArgs(enter, NULL); + Py_DECREF(enter); + if (res == NULL) + goto error; + PUSH(res); + DISPATCH(); + } + + TARGET(SETUP_ASYNC_WITH) { + PyObject *res = POP(); + /* Setup the finally block before pushing the result + of __aenter__ on the stack. */ + PyFrame_BlockSetup(f, SETUP_FINALLY, INSTR_OFFSET() + oparg, + STACK_LEVEL()); + PUSH(res); + DISPATCH(); + } + TARGET(SETUP_WITH) { _Py_IDENTIFIER(__exit__); _Py_IDENTIFIER(__enter__); @@ -2733,7 +3066,7 @@ PyEval_EvalFrameEx(PyFrameObject *f, int throwflag) DISPATCH(); } - TARGET(WITH_CLEANUP) { + TARGET(WITH_CLEANUP_START) { /* At the top of the stack are 1-6 values indicating how/why we entered the finally clause: - TOP = None @@ -2761,7 +3094,6 @@ PyEval_EvalFrameEx(PyFrameObject *f, int throwflag) PyObject *exit_func; PyObject *exc = TOP(), *val = Py_None, *tb = Py_None, *res; - int err; if (exc == Py_None) { (void)POP(); exit_func = TOP(); @@ -2811,11 +3143,26 @@ PyEval_EvalFrameEx(PyFrameObject *f, int throwflag) if (res == NULL) goto error; + Py_INCREF(exc); /* Duplicating the exception on the stack */ + PUSH(exc); + PUSH(res); + PREDICT(WITH_CLEANUP_FINISH); + DISPATCH(); + } + + PREDICTED(WITH_CLEANUP_FINISH); + TARGET(WITH_CLEANUP_FINISH) { + PyObject *res = POP(); + PyObject *exc = POP(); + int err; + if (exc != Py_None) err = PyObject_IsTrue(res); else err = 0; + Py_DECREF(res); + Py_DECREF(exc); if (err < 0) goto error; @@ -3026,6 +3373,7 @@ PyEval_EvalFrameEx(PyFrameObject *f, int throwflag) goto dispatch_opcode; } + #if USE_COMPUTED_GOTOS _unknown_opcode: #endif @@ -3168,11 +3516,10 @@ fast_block_end: if (why != WHY_RETURN) retval = NULL; - assert((retval != NULL && !PyErr_Occurred()) - || (retval == NULL && PyErr_Occurred())); + assert((retval != NULL) ^ (PyErr_Occurred() != NULL)); fast_yield: - if (co->co_flags & CO_GENERATOR) { + if (co->co_flags & (CO_GENERATOR | CO_COROUTINE)) { /* The purpose of this block is to put aside the generator's exception state and restore that of the calling frame. If the current @@ -3230,7 +3577,7 @@ exit_eval_frame: f->f_executing = 0; tstate->frame = f->f_back; - return retval; + return _Py_CheckFunctionResult(NULL, retval, "PyEval_EvalFrameEx"); } static void @@ -3387,10 +3734,11 @@ too_many_positional(PyCodeObject *co, int given, int defcount, PyObject **fastlo PyEval_EvalFrame() and PyEval_EvalCodeEx() you will need to adjust the test in the if statements in Misc/gdbinit (pystack and pystackv). */ -PyObject * -PyEval_EvalCodeEx(PyObject *_co, PyObject *globals, PyObject *locals, +static PyObject * +_PyEval_EvalCodeWithName(PyObject *_co, PyObject *globals, PyObject *locals, PyObject **args, int argcount, PyObject **kws, int kwcount, - PyObject **defs, int defcount, PyObject *kwdefs, PyObject *closure) + PyObject **defs, int defcount, PyObject *kwdefs, PyObject *closure, + PyObject *name, PyObject *qualname) { PyCodeObject* co = (PyCodeObject*)_co; PyFrameObject *f; @@ -3573,7 +3921,21 @@ PyEval_EvalCodeEx(PyObject *_co, PyObject *globals, PyObject *locals, freevars[PyTuple_GET_SIZE(co->co_cellvars) + i] = o; } - if (co->co_flags & CO_GENERATOR) { + if (co->co_flags & (CO_GENERATOR | CO_COROUTINE)) { + PyObject *gen; + PyObject *coro_wrapper = tstate->coroutine_wrapper; + int is_coro = co->co_flags & CO_COROUTINE; + + if (is_coro && tstate->in_coroutine_wrapper) { + assert(coro_wrapper != NULL); + PyErr_Format(PyExc_RuntimeError, + "coroutine wrapper %.200R attempted " + "to recursively wrap %.200R", + coro_wrapper, + co); + goto fail; + } + /* Don't need to keep the reference to f_back, it will be set * when the generator is resumed. */ Py_CLEAR(f->f_back); @@ -3582,7 +3944,23 @@ PyEval_EvalCodeEx(PyObject *_co, PyObject *globals, PyObject *locals, /* Create a new generator that owns the ready to run frame * and return that as the value. */ - return PyGen_New(f); + if (is_coro) { + gen = PyCoro_New(f, name, qualname); + } else { + gen = PyGen_NewWithQualName(f, name, qualname); + } + if (gen == NULL) + return NULL; + + if (is_coro && coro_wrapper != NULL) { + PyObject *wrapped; + tstate->in_coroutine_wrapper = 1; + wrapped = PyObject_CallFunction(coro_wrapper, "N", gen); + tstate->in_coroutine_wrapper = 0; + return wrapped; + } + + return gen; } retval = PyEval_EvalFrameEx(f,0); @@ -3601,6 +3979,16 @@ fail: /* Jump here from prelude on failure */ return retval; } +PyObject * +PyEval_EvalCodeEx(PyObject *_co, PyObject *globals, PyObject *locals, + PyObject **args, int argcount, PyObject **kws, int kwcount, + PyObject **defs, int defcount, PyObject *kwdefs, PyObject *closure) +{ + return _PyEval_EvalCodeWithName(_co, globals, locals, + args, argcount, kws, kwcount, + defs, defcount, kwdefs, closure, + NULL, NULL); +} static PyObject * special_lookup(PyObject *o, _Py_Identifier *id) @@ -3791,9 +4179,17 @@ unpack_iterable(PyObject *v, int argcnt, int argcntafter, PyObject **sp) if (w == NULL) { /* Iterator done, via error or exhaustion. */ if (!PyErr_Occurred()) { - PyErr_Format(PyExc_ValueError, - "need more than %d value%s to unpack", - i, i == 1 ? "" : "s"); + if (argcntafter == -1) { + PyErr_Format(PyExc_ValueError, + "not enough values to unpack (expected %d, got %d)", + argcnt, i); + } + else { + PyErr_Format(PyExc_ValueError, + "not enough values to unpack " + "(expected at least %d, got %d)", + argcnt + argcntafter, i); + } } goto Error; } @@ -3810,8 +4206,9 @@ unpack_iterable(PyObject *v, int argcnt, int argcntafter, PyObject **sp) return 1; } Py_DECREF(w); - PyErr_Format(PyExc_ValueError, "too many values to unpack " - "(expected %d)", argcnt); + PyErr_Format(PyExc_ValueError, + "too many values to unpack (expected %d)", + argcnt); goto Error; } @@ -3823,8 +4220,9 @@ unpack_iterable(PyObject *v, int argcnt, int argcntafter, PyObject **sp) ll = PyList_GET_SIZE(l); if (ll < argcntafter) { - PyErr_Format(PyExc_ValueError, "need more than %zd values to unpack", - argcnt + ll); + PyErr_Format(PyExc_ValueError, + "not enough values to unpack (expected at least %d, got %zd)", + argcnt + argcntafter, argcnt + ll); goto Error; } @@ -4008,6 +4406,24 @@ PyEval_SetTrace(Py_tracefunc func, PyObject *arg) || (tstate->c_profilefunc != NULL)); } +void +_PyEval_SetCoroutineWrapper(PyObject *wrapper) +{ + PyThreadState *tstate = PyThreadState_GET(); + + Py_CLEAR(tstate->coroutine_wrapper); + + Py_XINCREF(wrapper); + tstate->coroutine_wrapper = wrapper; +} + +PyObject * +_PyEval_GetCoroutineWrapper(void) +{ + PyThreadState *tstate = PyThreadState_GET(); + return tstate->coroutine_wrapper; +} + PyObject * PyEval_GetBuiltins(void) { @@ -4086,8 +4502,8 @@ PyEval_CallObjectWithKeywords(PyObject *func, PyObject *arg, PyObject *kw) #ifdef Py_DEBUG /* PyEval_CallObjectWithKeywords() must not be called with an exception - set, because it may clear it (directly or indirectly) - and so the caller loses its exception */ + set. It raises a new exception if parameters are invalid or if + PyTuple_New() fails, and so the original exception is lost. */ assert(!PyErr_Occurred()); #endif @@ -4114,8 +4530,6 @@ PyEval_CallObjectWithKeywords(PyObject *func, PyObject *arg, PyObject *kw) result = PyObject_Call(func, arg, kw); Py_DECREF(arg); - assert((result != NULL && !PyErr_Occurred()) - || (result == NULL && PyErr_Occurred())); return result; } @@ -4218,11 +4632,15 @@ call_function(PyObject ***pp_stack, int oparg PyObject *self = PyCFunction_GET_SELF(func); if (flags & METH_NOARGS && na == 0) { C_TRACE(x, (*meth)(self,NULL)); + + x = _Py_CheckFunctionResult(func, x, NULL); } else if (flags & METH_O && na == 1) { PyObject *arg = EXT_POP(*pp_stack); C_TRACE(x, (*meth)(self,arg)); Py_DECREF(arg); + + x = _Py_CheckFunctionResult(func, x, NULL); } else { err_args(func, flags, na); @@ -4242,7 +4660,8 @@ call_function(PyObject ***pp_stack, int oparg x = NULL; } } - } else { + } + else { if (PyMethod_Check(func) && PyMethod_GET_SELF(func) != NULL) { /* optimize access to bound methods */ PyObject *self = PyMethod_GET_SELF(func); @@ -4264,9 +4683,9 @@ call_function(PyObject ***pp_stack, int oparg x = do_call(func, pp_stack, na, nk); READ_TIMESTAMP(*pintr1); Py_DECREF(func); + + assert((x != NULL) ^ (PyErr_Occurred() != NULL)); } - assert((x != NULL && !PyErr_Occurred()) - || (x == NULL && PyErr_Occurred())); /* Clear the stack of the function object. Also removes the arguments in case they weren't consumed already @@ -4278,8 +4697,7 @@ call_function(PyObject ***pp_stack, int oparg PCALL(PCALL_POP); } - assert((x != NULL && !PyErr_Occurred()) - || (x == NULL && PyErr_Occurred())); + assert((x != NULL) ^ (PyErr_Occurred() != NULL)); return x; } @@ -4299,6 +4717,8 @@ fast_function(PyObject *func, PyObject ***pp_stack, int n, int na, int nk) PyObject *globals = PyFunction_GET_GLOBALS(func); PyObject *argdefs = PyFunction_GET_DEFAULTS(func); PyObject *kwdefs = PyFunction_GET_KW_DEFAULTS(func); + PyObject *name = ((PyFunctionObject *)func) -> func_name; + PyObject *qualname = ((PyFunctionObject *)func) -> func_qualname; PyObject **d = NULL; int nd = 0; @@ -4341,10 +4761,11 @@ fast_function(PyObject *func, PyObject ***pp_stack, int n, int na, int nk) d = &PyTuple_GET_ITEM(argdefs, 0); nd = Py_SIZE(argdefs); } - return PyEval_EvalCodeEx((PyObject*)co, globals, - (PyObject *)NULL, (*pp_stack)-n, na, - (*pp_stack)-2*nk, nk, d, nd, kwdefs, - PyFunction_GET_CLOSURE(func)); + return _PyEval_EvalCodeWithName((PyObject*)co, globals, + (PyObject *)NULL, (*pp_stack)-n, na, + (*pp_stack)-2*nk, nk, d, nd, kwdefs, + PyFunction_GET_CLOSURE(func), + name, qualname); } static PyObject * @@ -4508,6 +4929,12 @@ ext_do_call(PyObject *func, PyObject ***pp_stack, int flags, int na, int nk) 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)) { @@ -4529,11 +4956,6 @@ ext_do_call(PyObject *func, PyObject ***pp_stack, int flags, int na, int nk) } 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; @@ -4563,12 +4985,10 @@ ext_call_fail: Py_XDECREF(callargs); Py_XDECREF(kwdict); Py_XDECREF(stararg); - assert((result != NULL && !PyErr_Occurred()) - || (result == NULL && PyErr_Occurred())); return result; } -/* Extract a slice index from a PyInt or PyLong or an object with the +/* Extract a slice index from a PyLong or an object with the nb_index slot defined, and store in *pi. Silently reduce values larger than PY_SSIZE_T_MAX to PY_SSIZE_T_MAX, and silently boost values less than -PY_SSIZE_T_MAX-1 to -PY_SSIZE_T_MAX-1. @@ -4658,12 +5078,35 @@ static PyObject * import_from(PyObject *v, PyObject *name) { PyObject *x; + _Py_IDENTIFIER(__name__); + PyObject *fullmodname, *pkgname; x = PyObject_GetAttr(v, name); - if (x == NULL && PyErr_ExceptionMatches(PyExc_AttributeError)) { - PyErr_Format(PyExc_ImportError, "cannot import name %R", name); + if (x != NULL || !PyErr_ExceptionMatches(PyExc_AttributeError)) + return x; + /* Issue #17636: in case this failed because of a circular relative + import, try to fallback on reading the module directly from + sys.modules. */ + PyErr_Clear(); + pkgname = _PyObject_GetAttrId(v, &PyId___name__); + if (pkgname == NULL) { + goto error; + } + fullmodname = PyUnicode_FromFormat("%U.%U", pkgname, name); + Py_DECREF(pkgname); + if (fullmodname == NULL) { + return NULL; + } + x = PyDict_GetItem(PyImport_GetModuleDict(), fullmodname); + Py_DECREF(fullmodname); + if (x == NULL) { + goto error; } + Py_INCREF(x); return x; + error: + PyErr_Format(PyExc_ImportError, "cannot import name %R", name); + return NULL; } static int diff --git a/Python/ceval_gil.h b/Python/ceval_gil.h index 2702d5cbdd..aafcbc2bc9 100644 --- a/Python/ceval_gil.h +++ b/Python/ceval_gil.h @@ -31,7 +31,7 @@ static unsigned long gil_interval = DEFAULT_INTERVAL; variable (gil_drop_request) is used for that purpose, which is checked at every turn of the eval loop. That variable is set after a wait of `interval` microseconds on `gil_cond` has timed out. - + [Actually, another volatile boolean variable (eval_breaker) is used which ORs several conditions into one. Volatile booleans are sufficient as inter-thread signalling means since Python is run @@ -41,7 +41,7 @@ static unsigned long gil_interval = DEFAULT_INTERVAL; time (`interval` microseconds) before setting gil_drop_request. This encourages a defined switching period, but doesn't enforce it since opcodes can take an arbitrary time to execute. - + The `interval` value is available for the user to read and modify using the Python API `sys.{get,set}switchinterval()`. @@ -51,7 +51,7 @@ static unsigned long gil_interval = DEFAULT_INTERVAL; the value of gil_last_holder is changed to something else than its own thread state pointer, indicating that another thread was able to take the GIL. - + This is meant to prohibit the latency-adverse behaviour on multi-core machines where one thread would speculatively release the GIL, but still run and end up being the first to re-acquire it, making the "timeslices" @@ -186,12 +186,12 @@ static void drop_gil(PyThreadState *tstate) _Py_atomic_store_relaxed(&gil_locked, 0); COND_SIGNAL(gil_cond); MUTEX_UNLOCK(gil_mutex); - + #ifdef FORCE_SWITCHING if (_Py_atomic_load_relaxed(&gil_drop_request) && tstate != NULL) { MUTEX_LOCK(switch_mutex); /* Not switched yet => wait */ - if (_Py_atomic_load_relaxed(&gil_last_holder) == tstate) { + if ((PyThreadState*)_Py_atomic_load_relaxed(&gil_last_holder) == tstate) { RESET_GIL_DROP_REQUEST(); /* NOTE: if COND_WAIT does not atomically start waiting when releasing the mutex, another thread can run through, take @@ -215,7 +215,7 @@ static void take_gil(PyThreadState *tstate) if (!_Py_atomic_load_relaxed(&gil_locked)) goto _ready; - + while (_Py_atomic_load_relaxed(&gil_locked)) { int timed_out = 0; unsigned long saved_switchnum; @@ -239,7 +239,7 @@ _ready: _Py_atomic_store_relaxed(&gil_locked, 1); _Py_ANNOTATE_RWLOCK_ACQUIRED(&gil_locked, /*is_write=*/1); - if (tstate != _Py_atomic_load_relaxed(&gil_last_holder)) { + if (tstate != (PyThreadState*)_Py_atomic_load_relaxed(&gil_last_holder)) { _Py_atomic_store_relaxed(&gil_last_holder, tstate); ++gil_switch_number; } @@ -254,7 +254,7 @@ _ready: if (tstate->async_exc != NULL) { _PyEval_SignalAsyncExc(); } - + MUTEX_UNLOCK(gil_mutex); errno = err; } diff --git a/Python/clinic/bltinmodule.c.h b/Python/clinic/bltinmodule.c.h new file mode 100644 index 0000000000..7369148b23 --- /dev/null +++ b/Python/clinic/bltinmodule.c.h @@ -0,0 +1,663 @@ +/*[clinic input] +preserve +[clinic start generated code]*/ + +PyDoc_STRVAR(builtin_abs__doc__, +"abs($module, x, /)\n" +"--\n" +"\n" +"Return the absolute value of the argument."); + +#define BUILTIN_ABS_METHODDEF \ + {"abs", (PyCFunction)builtin_abs, METH_O, builtin_abs__doc__}, + +PyDoc_STRVAR(builtin_all__doc__, +"all($module, iterable, /)\n" +"--\n" +"\n" +"Return True if bool(x) is True for all values x in the iterable.\n" +"\n" +"If the iterable is empty, return True."); + +#define BUILTIN_ALL_METHODDEF \ + {"all", (PyCFunction)builtin_all, METH_O, builtin_all__doc__}, + +PyDoc_STRVAR(builtin_any__doc__, +"any($module, iterable, /)\n" +"--\n" +"\n" +"Return True if bool(x) is True for any x in the iterable.\n" +"\n" +"If the iterable is empty, return False."); + +#define BUILTIN_ANY_METHODDEF \ + {"any", (PyCFunction)builtin_any, METH_O, builtin_any__doc__}, + +PyDoc_STRVAR(builtin_ascii__doc__, +"ascii($module, obj, /)\n" +"--\n" +"\n" +"Return an ASCII-only representation of an object.\n" +"\n" +"As repr(), return a string containing a printable representation of an\n" +"object, but escape the non-ASCII characters in the string returned by\n" +"repr() using \\\\x, \\\\u or \\\\U escapes. This generates a string similar\n" +"to that returned by repr() in Python 2."); + +#define BUILTIN_ASCII_METHODDEF \ + {"ascii", (PyCFunction)builtin_ascii, METH_O, builtin_ascii__doc__}, + +PyDoc_STRVAR(builtin_bin__doc__, +"bin($module, number, /)\n" +"--\n" +"\n" +"Return the binary representation of an integer.\n" +"\n" +" >>> bin(2796202)\n" +" \'0b1010101010101010101010\'"); + +#define BUILTIN_BIN_METHODDEF \ + {"bin", (PyCFunction)builtin_bin, METH_O, builtin_bin__doc__}, + +PyDoc_STRVAR(builtin_callable__doc__, +"callable($module, obj, /)\n" +"--\n" +"\n" +"Return whether the object is callable (i.e., some kind of function).\n" +"\n" +"Note that classes are callable, as are instances of classes with a\n" +"__call__() method."); + +#define BUILTIN_CALLABLE_METHODDEF \ + {"callable", (PyCFunction)builtin_callable, METH_O, builtin_callable__doc__}, + +PyDoc_STRVAR(builtin_format__doc__, +"format($module, value, format_spec=\'\', /)\n" +"--\n" +"\n" +"Return value.__format__(format_spec)\n" +"\n" +"format_spec defaults to the empty string"); + +#define BUILTIN_FORMAT_METHODDEF \ + {"format", (PyCFunction)builtin_format, METH_VARARGS, builtin_format__doc__}, + +static PyObject * +builtin_format_impl(PyModuleDef *module, PyObject *value, + PyObject *format_spec); + +static PyObject * +builtin_format(PyModuleDef *module, PyObject *args) +{ + PyObject *return_value = NULL; + PyObject *value; + PyObject *format_spec = NULL; + + if (!PyArg_ParseTuple(args, "O|U:format", + &value, &format_spec)) + goto exit; + return_value = builtin_format_impl(module, value, format_spec); + +exit: + return return_value; +} + +PyDoc_STRVAR(builtin_chr__doc__, +"chr($module, i, /)\n" +"--\n" +"\n" +"Return a Unicode string of one character with ordinal i; 0 <= i <= 0x10ffff."); + +#define BUILTIN_CHR_METHODDEF \ + {"chr", (PyCFunction)builtin_chr, METH_O, builtin_chr__doc__}, + +static PyObject * +builtin_chr_impl(PyModuleDef *module, int i); + +static PyObject * +builtin_chr(PyModuleDef *module, PyObject *arg) +{ + PyObject *return_value = NULL; + int i; + + if (!PyArg_Parse(arg, "i:chr", &i)) + goto exit; + return_value = builtin_chr_impl(module, i); + +exit: + return return_value; +} + +PyDoc_STRVAR(builtin_compile__doc__, +"compile($module, /, source, filename, mode, flags=0,\n" +" dont_inherit=False, optimize=-1)\n" +"--\n" +"\n" +"Compile source into a code object that can be executed by exec() or eval().\n" +"\n" +"The source code may represent a Python module, statement or expression.\n" +"The filename will be used for run-time error messages.\n" +"The mode must be \'exec\' to compile a module, \'single\' to compile a\n" +"single (interactive) statement, or \'eval\' to compile an expression.\n" +"The flags argument, if present, controls which future statements influence\n" +"the compilation of the code.\n" +"The dont_inherit argument, if true, stops the compilation inheriting\n" +"the effects of any future statements in effect in the code calling\n" +"compile; if absent or false these statements do influence the compilation,\n" +"in addition to any features explicitly specified."); + +#define BUILTIN_COMPILE_METHODDEF \ + {"compile", (PyCFunction)builtin_compile, METH_VARARGS|METH_KEYWORDS, builtin_compile__doc__}, + +static PyObject * +builtin_compile_impl(PyModuleDef *module, PyObject *source, + PyObject *filename, const char *mode, int flags, + int dont_inherit, int optimize); + +static PyObject * +builtin_compile(PyModuleDef *module, PyObject *args, PyObject *kwargs) +{ + PyObject *return_value = NULL; + static char *_keywords[] = {"source", "filename", "mode", "flags", "dont_inherit", "optimize", NULL}; + PyObject *source; + PyObject *filename; + const char *mode; + int flags = 0; + int dont_inherit = 0; + int optimize = -1; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO&s|iii:compile", _keywords, + &source, PyUnicode_FSDecoder, &filename, &mode, &flags, &dont_inherit, &optimize)) + goto exit; + return_value = builtin_compile_impl(module, source, filename, mode, flags, dont_inherit, optimize); + +exit: + return return_value; +} + +PyDoc_STRVAR(builtin_divmod__doc__, +"divmod($module, x, y, /)\n" +"--\n" +"\n" +"Return the tuple ((x-x%y)/y, x%y). Invariant: div*y + mod == x."); + +#define BUILTIN_DIVMOD_METHODDEF \ + {"divmod", (PyCFunction)builtin_divmod, METH_VARARGS, builtin_divmod__doc__}, + +static PyObject * +builtin_divmod_impl(PyModuleDef *module, PyObject *x, PyObject *y); + +static PyObject * +builtin_divmod(PyModuleDef *module, PyObject *args) +{ + PyObject *return_value = NULL; + PyObject *x; + PyObject *y; + + if (!PyArg_UnpackTuple(args, "divmod", + 2, 2, + &x, &y)) + goto exit; + return_value = builtin_divmod_impl(module, x, y); + +exit: + return return_value; +} + +PyDoc_STRVAR(builtin_eval__doc__, +"eval($module, source, globals=None, locals=None, /)\n" +"--\n" +"\n" +"Evaluate the given source in the context of globals and locals.\n" +"\n" +"The source may be a string representing a Python expression\n" +"or a code object as returned by compile().\n" +"The globals must be a dictionary and locals can be any mapping,\n" +"defaulting to the current globals and locals.\n" +"If only globals is given, locals defaults to it."); + +#define BUILTIN_EVAL_METHODDEF \ + {"eval", (PyCFunction)builtin_eval, METH_VARARGS, builtin_eval__doc__}, + +static PyObject * +builtin_eval_impl(PyModuleDef *module, PyObject *source, PyObject *globals, + PyObject *locals); + +static PyObject * +builtin_eval(PyModuleDef *module, PyObject *args) +{ + PyObject *return_value = NULL; + PyObject *source; + PyObject *globals = Py_None; + PyObject *locals = Py_None; + + if (!PyArg_UnpackTuple(args, "eval", + 1, 3, + &source, &globals, &locals)) + goto exit; + return_value = builtin_eval_impl(module, source, globals, locals); + +exit: + return return_value; +} + +PyDoc_STRVAR(builtin_exec__doc__, +"exec($module, source, globals=None, locals=None, /)\n" +"--\n" +"\n" +"Execute the given source in the context of globals and locals.\n" +"\n" +"The source may be a string representing one or more Python statements\n" +"or a code object as returned by compile().\n" +"The globals must be a dictionary and locals can be any mapping,\n" +"defaulting to the current globals and locals.\n" +"If only globals is given, locals defaults to it."); + +#define BUILTIN_EXEC_METHODDEF \ + {"exec", (PyCFunction)builtin_exec, METH_VARARGS, builtin_exec__doc__}, + +static PyObject * +builtin_exec_impl(PyModuleDef *module, PyObject *source, PyObject *globals, + PyObject *locals); + +static PyObject * +builtin_exec(PyModuleDef *module, PyObject *args) +{ + PyObject *return_value = NULL; + PyObject *source; + PyObject *globals = Py_None; + PyObject *locals = Py_None; + + if (!PyArg_UnpackTuple(args, "exec", + 1, 3, + &source, &globals, &locals)) + goto exit; + return_value = builtin_exec_impl(module, source, globals, locals); + +exit: + return return_value; +} + +PyDoc_STRVAR(builtin_globals__doc__, +"globals($module, /)\n" +"--\n" +"\n" +"Return the dictionary containing the current scope\'s global variables.\n" +"\n" +"NOTE: Updates to this dictionary *will* affect name lookups in the current\n" +"global scope and vice-versa."); + +#define BUILTIN_GLOBALS_METHODDEF \ + {"globals", (PyCFunction)builtin_globals, METH_NOARGS, builtin_globals__doc__}, + +static PyObject * +builtin_globals_impl(PyModuleDef *module); + +static PyObject * +builtin_globals(PyModuleDef *module, PyObject *Py_UNUSED(ignored)) +{ + return builtin_globals_impl(module); +} + +PyDoc_STRVAR(builtin_hasattr__doc__, +"hasattr($module, obj, name, /)\n" +"--\n" +"\n" +"Return whether the object has an attribute with the given name.\n" +"\n" +"This is done by calling getattr(obj, name) and catching AttributeError."); + +#define BUILTIN_HASATTR_METHODDEF \ + {"hasattr", (PyCFunction)builtin_hasattr, METH_VARARGS, builtin_hasattr__doc__}, + +static PyObject * +builtin_hasattr_impl(PyModuleDef *module, PyObject *obj, PyObject *name); + +static PyObject * +builtin_hasattr(PyModuleDef *module, PyObject *args) +{ + PyObject *return_value = NULL; + PyObject *obj; + PyObject *name; + + if (!PyArg_UnpackTuple(args, "hasattr", + 2, 2, + &obj, &name)) + goto exit; + return_value = builtin_hasattr_impl(module, obj, name); + +exit: + return return_value; +} + +PyDoc_STRVAR(builtin_id__doc__, +"id($module, obj, /)\n" +"--\n" +"\n" +"Return the identity of an object.\n" +"\n" +"This is guaranteed to be unique among simultaneously existing objects.\n" +"(CPython uses the object\'s memory address.)"); + +#define BUILTIN_ID_METHODDEF \ + {"id", (PyCFunction)builtin_id, METH_O, builtin_id__doc__}, + +PyDoc_STRVAR(builtin_setattr__doc__, +"setattr($module, obj, name, value, /)\n" +"--\n" +"\n" +"Sets the named attribute on the given object to the specified value.\n" +"\n" +"setattr(x, \'y\', v) is equivalent to ``x.y = v\'\'"); + +#define BUILTIN_SETATTR_METHODDEF \ + {"setattr", (PyCFunction)builtin_setattr, METH_VARARGS, builtin_setattr__doc__}, + +static PyObject * +builtin_setattr_impl(PyModuleDef *module, PyObject *obj, PyObject *name, + PyObject *value); + +static PyObject * +builtin_setattr(PyModuleDef *module, PyObject *args) +{ + PyObject *return_value = NULL; + PyObject *obj; + PyObject *name; + PyObject *value; + + if (!PyArg_UnpackTuple(args, "setattr", + 3, 3, + &obj, &name, &value)) + goto exit; + return_value = builtin_setattr_impl(module, obj, name, value); + +exit: + return return_value; +} + +PyDoc_STRVAR(builtin_delattr__doc__, +"delattr($module, obj, name, /)\n" +"--\n" +"\n" +"Deletes the named attribute from the given object.\n" +"\n" +"delattr(x, \'y\') is equivalent to ``del x.y\'\'"); + +#define BUILTIN_DELATTR_METHODDEF \ + {"delattr", (PyCFunction)builtin_delattr, METH_VARARGS, builtin_delattr__doc__}, + +static PyObject * +builtin_delattr_impl(PyModuleDef *module, PyObject *obj, PyObject *name); + +static PyObject * +builtin_delattr(PyModuleDef *module, PyObject *args) +{ + PyObject *return_value = NULL; + PyObject *obj; + PyObject *name; + + if (!PyArg_UnpackTuple(args, "delattr", + 2, 2, + &obj, &name)) + goto exit; + return_value = builtin_delattr_impl(module, obj, name); + +exit: + return return_value; +} + +PyDoc_STRVAR(builtin_hash__doc__, +"hash($module, obj, /)\n" +"--\n" +"\n" +"Return the hash value for the given object.\n" +"\n" +"Two objects that compare equal must also have the same hash value, but the\n" +"reverse is not necessarily true."); + +#define BUILTIN_HASH_METHODDEF \ + {"hash", (PyCFunction)builtin_hash, METH_O, builtin_hash__doc__}, + +PyDoc_STRVAR(builtin_hex__doc__, +"hex($module, number, /)\n" +"--\n" +"\n" +"Return the hexadecimal representation of an integer.\n" +"\n" +" >>> hex(12648430)\n" +" \'0xc0ffee\'"); + +#define BUILTIN_HEX_METHODDEF \ + {"hex", (PyCFunction)builtin_hex, METH_O, builtin_hex__doc__}, + +PyDoc_STRVAR(builtin_len__doc__, +"len($module, obj, /)\n" +"--\n" +"\n" +"Return the number of items in a container."); + +#define BUILTIN_LEN_METHODDEF \ + {"len", (PyCFunction)builtin_len, METH_O, builtin_len__doc__}, + +PyDoc_STRVAR(builtin_locals__doc__, +"locals($module, /)\n" +"--\n" +"\n" +"Return a dictionary containing the current scope\'s local variables.\n" +"\n" +"NOTE: Whether or not updates to this dictionary will affect name lookups in\n" +"the local scope and vice-versa is *implementation dependent* and not\n" +"covered by any backwards compatibility guarantees."); + +#define BUILTIN_LOCALS_METHODDEF \ + {"locals", (PyCFunction)builtin_locals, METH_NOARGS, builtin_locals__doc__}, + +static PyObject * +builtin_locals_impl(PyModuleDef *module); + +static PyObject * +builtin_locals(PyModuleDef *module, PyObject *Py_UNUSED(ignored)) +{ + return builtin_locals_impl(module); +} + +PyDoc_STRVAR(builtin_oct__doc__, +"oct($module, number, /)\n" +"--\n" +"\n" +"Return the octal representation of an integer.\n" +"\n" +" >>> oct(342391)\n" +" \'0o1234567\'"); + +#define BUILTIN_OCT_METHODDEF \ + {"oct", (PyCFunction)builtin_oct, METH_O, builtin_oct__doc__}, + +PyDoc_STRVAR(builtin_ord__doc__, +"ord($module, c, /)\n" +"--\n" +"\n" +"Return the Unicode code point for a one-character string."); + +#define BUILTIN_ORD_METHODDEF \ + {"ord", (PyCFunction)builtin_ord, METH_O, builtin_ord__doc__}, + +PyDoc_STRVAR(builtin_pow__doc__, +"pow($module, x, y, z=None, /)\n" +"--\n" +"\n" +"Equivalent to x**y (with two arguments) or x**y % z (with three arguments)\n" +"\n" +"Some types, such as ints, are able to use a more efficient algorithm when\n" +"invoked using the three argument form."); + +#define BUILTIN_POW_METHODDEF \ + {"pow", (PyCFunction)builtin_pow, METH_VARARGS, builtin_pow__doc__}, + +static PyObject * +builtin_pow_impl(PyModuleDef *module, PyObject *x, PyObject *y, PyObject *z); + +static PyObject * +builtin_pow(PyModuleDef *module, PyObject *args) +{ + PyObject *return_value = NULL; + PyObject *x; + PyObject *y; + PyObject *z = Py_None; + + if (!PyArg_UnpackTuple(args, "pow", + 2, 3, + &x, &y, &z)) + goto exit; + return_value = builtin_pow_impl(module, x, y, z); + +exit: + return return_value; +} + +PyDoc_STRVAR(builtin_input__doc__, +"input($module, prompt=None, /)\n" +"--\n" +"\n" +"Read a string from standard input. The trailing newline is stripped.\n" +"\n" +"The prompt string, if given, is printed to standard output without a\n" +"trailing newline before reading input.\n" +"\n" +"If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.\n" +"On *nix systems, readline is used if available."); + +#define BUILTIN_INPUT_METHODDEF \ + {"input", (PyCFunction)builtin_input, METH_VARARGS, builtin_input__doc__}, + +static PyObject * +builtin_input_impl(PyModuleDef *module, PyObject *prompt); + +static PyObject * +builtin_input(PyModuleDef *module, PyObject *args) +{ + PyObject *return_value = NULL; + PyObject *prompt = NULL; + + if (!PyArg_UnpackTuple(args, "input", + 0, 1, + &prompt)) + goto exit; + return_value = builtin_input_impl(module, prompt); + +exit: + return return_value; +} + +PyDoc_STRVAR(builtin_repr__doc__, +"repr($module, obj, /)\n" +"--\n" +"\n" +"Return the canonical string representation of the object.\n" +"\n" +"For many object types, including most builtins, eval(repr(obj)) == obj."); + +#define BUILTIN_REPR_METHODDEF \ + {"repr", (PyCFunction)builtin_repr, METH_O, builtin_repr__doc__}, + +PyDoc_STRVAR(builtin_sum__doc__, +"sum($module, iterable, start=0, /)\n" +"--\n" +"\n" +"Return the sum of a \'start\' value (default: 0) plus an iterable of numbers\n" +"\n" +"When the iterable is empty, return the start value.\n" +"This function is intended specifically for use with numeric values and may\n" +"reject non-numeric types."); + +#define BUILTIN_SUM_METHODDEF \ + {"sum", (PyCFunction)builtin_sum, METH_VARARGS, builtin_sum__doc__}, + +static PyObject * +builtin_sum_impl(PyModuleDef *module, PyObject *iterable, PyObject *start); + +static PyObject * +builtin_sum(PyModuleDef *module, PyObject *args) +{ + PyObject *return_value = NULL; + PyObject *iterable; + PyObject *start = NULL; + + if (!PyArg_UnpackTuple(args, "sum", + 1, 2, + &iterable, &start)) + goto exit; + return_value = builtin_sum_impl(module, iterable, start); + +exit: + return return_value; +} + +PyDoc_STRVAR(builtin_isinstance__doc__, +"isinstance($module, obj, class_or_tuple, /)\n" +"--\n" +"\n" +"Return whether an object is an instance of a class or of a subclass thereof.\n" +"\n" +"A tuple, as in ``isinstance(x, (A, B, ...))``, may be given as the target to\n" +"check against. This is equivalent to ``isinstance(x, A) or isinstance(x, B)\n" +"or ...`` etc."); + +#define BUILTIN_ISINSTANCE_METHODDEF \ + {"isinstance", (PyCFunction)builtin_isinstance, METH_VARARGS, builtin_isinstance__doc__}, + +static PyObject * +builtin_isinstance_impl(PyModuleDef *module, PyObject *obj, + PyObject *class_or_tuple); + +static PyObject * +builtin_isinstance(PyModuleDef *module, PyObject *args) +{ + PyObject *return_value = NULL; + PyObject *obj; + PyObject *class_or_tuple; + + if (!PyArg_UnpackTuple(args, "isinstance", + 2, 2, + &obj, &class_or_tuple)) + goto exit; + return_value = builtin_isinstance_impl(module, obj, class_or_tuple); + +exit: + return return_value; +} + +PyDoc_STRVAR(builtin_issubclass__doc__, +"issubclass($module, cls, class_or_tuple, /)\n" +"--\n" +"\n" +"Return whether \'cls\' is a derived from another class or is the same class.\n" +"\n" +"A tuple, as in ``issubclass(x, (A, B, ...))``, may be given as the target to\n" +"check against. This is equivalent to ``issubclass(x, A) or issubclass(x, B)\n" +"or ...`` etc."); + +#define BUILTIN_ISSUBCLASS_METHODDEF \ + {"issubclass", (PyCFunction)builtin_issubclass, METH_VARARGS, builtin_issubclass__doc__}, + +static PyObject * +builtin_issubclass_impl(PyModuleDef *module, PyObject *cls, + PyObject *class_or_tuple); + +static PyObject * +builtin_issubclass(PyModuleDef *module, PyObject *args) +{ + PyObject *return_value = NULL; + PyObject *cls; + PyObject *class_or_tuple; + + if (!PyArg_UnpackTuple(args, "issubclass", + 2, 2, + &cls, &class_or_tuple)) + goto exit; + return_value = builtin_issubclass_impl(module, cls, class_or_tuple); + +exit: + return return_value; +} +/*[clinic end generated code: output=bec3399c0aee98d7 input=a9049054013a1b77]*/ diff --git a/Python/clinic/import.c.h b/Python/clinic/import.c.h new file mode 100644 index 0000000000..247766519e --- /dev/null +++ b/Python/clinic/import.c.h @@ -0,0 +1,355 @@ +/*[clinic input] +preserve +[clinic start generated code]*/ + +PyDoc_STRVAR(_imp_lock_held__doc__, +"lock_held($module, /)\n" +"--\n" +"\n" +"Return True if the import lock is currently held, else False.\n" +"\n" +"On platforms without threads, return False."); + +#define _IMP_LOCK_HELD_METHODDEF \ + {"lock_held", (PyCFunction)_imp_lock_held, METH_NOARGS, _imp_lock_held__doc__}, + +static PyObject * +_imp_lock_held_impl(PyModuleDef *module); + +static PyObject * +_imp_lock_held(PyModuleDef *module, PyObject *Py_UNUSED(ignored)) +{ + return _imp_lock_held_impl(module); +} + +PyDoc_STRVAR(_imp_acquire_lock__doc__, +"acquire_lock($module, /)\n" +"--\n" +"\n" +"Acquires the interpreter\'s import lock for the current thread.\n" +"\n" +"This lock should be used by import hooks to ensure thread-safety when importing\n" +"modules. On platforms without threads, this function does nothing."); + +#define _IMP_ACQUIRE_LOCK_METHODDEF \ + {"acquire_lock", (PyCFunction)_imp_acquire_lock, METH_NOARGS, _imp_acquire_lock__doc__}, + +static PyObject * +_imp_acquire_lock_impl(PyModuleDef *module); + +static PyObject * +_imp_acquire_lock(PyModuleDef *module, PyObject *Py_UNUSED(ignored)) +{ + return _imp_acquire_lock_impl(module); +} + +PyDoc_STRVAR(_imp_release_lock__doc__, +"release_lock($module, /)\n" +"--\n" +"\n" +"Release the interpreter\'s import lock.\n" +"\n" +"On platforms without threads, this function does nothing."); + +#define _IMP_RELEASE_LOCK_METHODDEF \ + {"release_lock", (PyCFunction)_imp_release_lock, METH_NOARGS, _imp_release_lock__doc__}, + +static PyObject * +_imp_release_lock_impl(PyModuleDef *module); + +static PyObject * +_imp_release_lock(PyModuleDef *module, PyObject *Py_UNUSED(ignored)) +{ + return _imp_release_lock_impl(module); +} + +PyDoc_STRVAR(_imp__fix_co_filename__doc__, +"_fix_co_filename($module, code, path, /)\n" +"--\n" +"\n" +"Changes code.co_filename to specify the passed-in file path.\n" +"\n" +" code\n" +" Code object to change.\n" +" path\n" +" File path to use."); + +#define _IMP__FIX_CO_FILENAME_METHODDEF \ + {"_fix_co_filename", (PyCFunction)_imp__fix_co_filename, METH_VARARGS, _imp__fix_co_filename__doc__}, + +static PyObject * +_imp__fix_co_filename_impl(PyModuleDef *module, PyCodeObject *code, + PyObject *path); + +static PyObject * +_imp__fix_co_filename(PyModuleDef *module, PyObject *args) +{ + PyObject *return_value = NULL; + PyCodeObject *code; + PyObject *path; + + if (!PyArg_ParseTuple(args, "O!U:_fix_co_filename", + &PyCode_Type, &code, &path)) + goto exit; + return_value = _imp__fix_co_filename_impl(module, code, path); + +exit: + return return_value; +} + +PyDoc_STRVAR(_imp_create_builtin__doc__, +"create_builtin($module, spec, /)\n" +"--\n" +"\n" +"Create an extension module."); + +#define _IMP_CREATE_BUILTIN_METHODDEF \ + {"create_builtin", (PyCFunction)_imp_create_builtin, METH_O, _imp_create_builtin__doc__}, + +PyDoc_STRVAR(_imp_extension_suffixes__doc__, +"extension_suffixes($module, /)\n" +"--\n" +"\n" +"Returns the list of file suffixes used to identify extension modules."); + +#define _IMP_EXTENSION_SUFFIXES_METHODDEF \ + {"extension_suffixes", (PyCFunction)_imp_extension_suffixes, METH_NOARGS, _imp_extension_suffixes__doc__}, + +static PyObject * +_imp_extension_suffixes_impl(PyModuleDef *module); + +static PyObject * +_imp_extension_suffixes(PyModuleDef *module, PyObject *Py_UNUSED(ignored)) +{ + return _imp_extension_suffixes_impl(module); +} + +PyDoc_STRVAR(_imp_init_frozen__doc__, +"init_frozen($module, name, /)\n" +"--\n" +"\n" +"Initializes a frozen module."); + +#define _IMP_INIT_FROZEN_METHODDEF \ + {"init_frozen", (PyCFunction)_imp_init_frozen, METH_O, _imp_init_frozen__doc__}, + +static PyObject * +_imp_init_frozen_impl(PyModuleDef *module, PyObject *name); + +static PyObject * +_imp_init_frozen(PyModuleDef *module, PyObject *arg) +{ + PyObject *return_value = NULL; + PyObject *name; + + if (!PyArg_Parse(arg, "U:init_frozen", &name)) + goto exit; + return_value = _imp_init_frozen_impl(module, name); + +exit: + return return_value; +} + +PyDoc_STRVAR(_imp_get_frozen_object__doc__, +"get_frozen_object($module, name, /)\n" +"--\n" +"\n" +"Create a code object for a frozen module."); + +#define _IMP_GET_FROZEN_OBJECT_METHODDEF \ + {"get_frozen_object", (PyCFunction)_imp_get_frozen_object, METH_O, _imp_get_frozen_object__doc__}, + +static PyObject * +_imp_get_frozen_object_impl(PyModuleDef *module, PyObject *name); + +static PyObject * +_imp_get_frozen_object(PyModuleDef *module, PyObject *arg) +{ + PyObject *return_value = NULL; + PyObject *name; + + if (!PyArg_Parse(arg, "U:get_frozen_object", &name)) + goto exit; + return_value = _imp_get_frozen_object_impl(module, name); + +exit: + return return_value; +} + +PyDoc_STRVAR(_imp_is_frozen_package__doc__, +"is_frozen_package($module, name, /)\n" +"--\n" +"\n" +"Returns True if the module name is of a frozen package."); + +#define _IMP_IS_FROZEN_PACKAGE_METHODDEF \ + {"is_frozen_package", (PyCFunction)_imp_is_frozen_package, METH_O, _imp_is_frozen_package__doc__}, + +static PyObject * +_imp_is_frozen_package_impl(PyModuleDef *module, PyObject *name); + +static PyObject * +_imp_is_frozen_package(PyModuleDef *module, PyObject *arg) +{ + PyObject *return_value = NULL; + PyObject *name; + + if (!PyArg_Parse(arg, "U:is_frozen_package", &name)) + goto exit; + return_value = _imp_is_frozen_package_impl(module, name); + +exit: + return return_value; +} + +PyDoc_STRVAR(_imp_is_builtin__doc__, +"is_builtin($module, name, /)\n" +"--\n" +"\n" +"Returns True if the module name corresponds to a built-in module."); + +#define _IMP_IS_BUILTIN_METHODDEF \ + {"is_builtin", (PyCFunction)_imp_is_builtin, METH_O, _imp_is_builtin__doc__}, + +static PyObject * +_imp_is_builtin_impl(PyModuleDef *module, PyObject *name); + +static PyObject * +_imp_is_builtin(PyModuleDef *module, PyObject *arg) +{ + PyObject *return_value = NULL; + PyObject *name; + + if (!PyArg_Parse(arg, "U:is_builtin", &name)) + goto exit; + return_value = _imp_is_builtin_impl(module, name); + +exit: + return return_value; +} + +PyDoc_STRVAR(_imp_is_frozen__doc__, +"is_frozen($module, name, /)\n" +"--\n" +"\n" +"Returns True if the module name corresponds to a frozen module."); + +#define _IMP_IS_FROZEN_METHODDEF \ + {"is_frozen", (PyCFunction)_imp_is_frozen, METH_O, _imp_is_frozen__doc__}, + +static PyObject * +_imp_is_frozen_impl(PyModuleDef *module, PyObject *name); + +static PyObject * +_imp_is_frozen(PyModuleDef *module, PyObject *arg) +{ + PyObject *return_value = NULL; + PyObject *name; + + if (!PyArg_Parse(arg, "U:is_frozen", &name)) + goto exit; + return_value = _imp_is_frozen_impl(module, name); + +exit: + return return_value; +} + +#if defined(HAVE_DYNAMIC_LOADING) + +PyDoc_STRVAR(_imp_create_dynamic__doc__, +"create_dynamic($module, spec, file=None, /)\n" +"--\n" +"\n" +"Create an extension module."); + +#define _IMP_CREATE_DYNAMIC_METHODDEF \ + {"create_dynamic", (PyCFunction)_imp_create_dynamic, METH_VARARGS, _imp_create_dynamic__doc__}, + +static PyObject * +_imp_create_dynamic_impl(PyModuleDef *module, PyObject *spec, PyObject *file); + +static PyObject * +_imp_create_dynamic(PyModuleDef *module, PyObject *args) +{ + PyObject *return_value = NULL; + PyObject *spec; + PyObject *file = NULL; + + if (!PyArg_UnpackTuple(args, "create_dynamic", + 1, 2, + &spec, &file)) + goto exit; + return_value = _imp_create_dynamic_impl(module, spec, file); + +exit: + return return_value; +} + +#endif /* defined(HAVE_DYNAMIC_LOADING) */ + +#if defined(HAVE_DYNAMIC_LOADING) + +PyDoc_STRVAR(_imp_exec_dynamic__doc__, +"exec_dynamic($module, mod, /)\n" +"--\n" +"\n" +"Initialize an extension module."); + +#define _IMP_EXEC_DYNAMIC_METHODDEF \ + {"exec_dynamic", (PyCFunction)_imp_exec_dynamic, METH_O, _imp_exec_dynamic__doc__}, + +static int +_imp_exec_dynamic_impl(PyModuleDef *module, PyObject *mod); + +static PyObject * +_imp_exec_dynamic(PyModuleDef *module, PyObject *mod) +{ + PyObject *return_value = NULL; + int _return_value; + + _return_value = _imp_exec_dynamic_impl(module, mod); + if ((_return_value == -1) && PyErr_Occurred()) + goto exit; + return_value = PyLong_FromLong((long)_return_value); + +exit: + return return_value; +} + +#endif /* defined(HAVE_DYNAMIC_LOADING) */ + +PyDoc_STRVAR(_imp_exec_builtin__doc__, +"exec_builtin($module, mod, /)\n" +"--\n" +"\n" +"Initialize a built-in module."); + +#define _IMP_EXEC_BUILTIN_METHODDEF \ + {"exec_builtin", (PyCFunction)_imp_exec_builtin, METH_O, _imp_exec_builtin__doc__}, + +static int +_imp_exec_builtin_impl(PyModuleDef *module, PyObject *mod); + +static PyObject * +_imp_exec_builtin(PyModuleDef *module, PyObject *mod) +{ + PyObject *return_value = NULL; + int _return_value; + + _return_value = _imp_exec_builtin_impl(module, mod); + if ((_return_value == -1) && PyErr_Occurred()) + goto exit; + return_value = PyLong_FromLong((long)_return_value); + +exit: + return return_value; +} + +#ifndef _IMP_CREATE_DYNAMIC_METHODDEF + #define _IMP_CREATE_DYNAMIC_METHODDEF +#endif /* !defined(_IMP_CREATE_DYNAMIC_METHODDEF) */ + +#ifndef _IMP_EXEC_DYNAMIC_METHODDEF + #define _IMP_EXEC_DYNAMIC_METHODDEF +#endif /* !defined(_IMP_EXEC_DYNAMIC_METHODDEF) */ +/*[clinic end generated code: output=32324a5e46cdfc4b input=a9049054013a1b77]*/ diff --git a/Python/codecs.c b/Python/codecs.c index 27f2aebf82..d90bf7374d 100644 --- a/Python/codecs.c +++ b/Python/codecs.c @@ -9,6 +9,7 @@ Copyright (c) Corporation for National Research Initiatives. ------------------------------------------------------------------------ */ #include "Python.h" +#include "ucnhash.h" #include <ctype.h> const char *Py_hexdigits = "0123456789abcdef"; @@ -856,6 +857,118 @@ PyObject *PyCodec_XMLCharRefReplaceErrors(PyObject *exc) PyObject *PyCodec_BackslashReplaceErrors(PyObject *exc) { + PyObject *object; + Py_ssize_t i; + Py_ssize_t start; + Py_ssize_t end; + PyObject *res; + unsigned char *outp; + int ressize; + Py_UCS4 c; + + if (PyObject_TypeCheck(exc, (PyTypeObject *)PyExc_UnicodeDecodeError)) { + unsigned char *p; + if (PyUnicodeDecodeError_GetStart(exc, &start)) + return NULL; + if (PyUnicodeDecodeError_GetEnd(exc, &end)) + return NULL; + if (!(object = PyUnicodeDecodeError_GetObject(exc))) + return NULL; + if (!(p = (unsigned char*)PyBytes_AsString(object))) { + Py_DECREF(object); + return NULL; + } + res = PyUnicode_New(4 * (end - start), 127); + if (res == NULL) { + Py_DECREF(object); + return NULL; + } + outp = PyUnicode_1BYTE_DATA(res); + for (i = start; i < end; i++, outp += 4) { + unsigned char c = p[i]; + outp[0] = '\\'; + outp[1] = 'x'; + outp[2] = Py_hexdigits[(c>>4)&0xf]; + outp[3] = Py_hexdigits[c&0xf]; + } + + assert(_PyUnicode_CheckConsistency(res, 1)); + Py_DECREF(object); + return Py_BuildValue("(Nn)", res, end); + } + if (PyObject_TypeCheck(exc, (PyTypeObject *)PyExc_UnicodeEncodeError)) { + if (PyUnicodeEncodeError_GetStart(exc, &start)) + return NULL; + if (PyUnicodeEncodeError_GetEnd(exc, &end)) + return NULL; + if (!(object = PyUnicodeEncodeError_GetObject(exc))) + return NULL; + } + else if (PyObject_TypeCheck(exc, (PyTypeObject *)PyExc_UnicodeTranslateError)) { + if (PyUnicodeTranslateError_GetStart(exc, &start)) + return NULL; + if (PyUnicodeTranslateError_GetEnd(exc, &end)) + return NULL; + if (!(object = PyUnicodeTranslateError_GetObject(exc))) + return NULL; + } + else { + wrong_exception_type(exc); + return NULL; + } + + if (end - start > PY_SSIZE_T_MAX / (1+1+8)) + end = start + PY_SSIZE_T_MAX / (1+1+8); + for (i = start, ressize = 0; i < end; ++i) { + /* object is guaranteed to be "ready" */ + c = PyUnicode_READ_CHAR(object, i); + if (c >= 0x10000) { + ressize += 1+1+8; + } + else if (c >= 0x100) { + ressize += 1+1+4; + } + else + ressize += 1+1+2; + } + res = PyUnicode_New(ressize, 127); + if (res == NULL) { + Py_DECREF(object); + return NULL; + } + outp = PyUnicode_1BYTE_DATA(res); + for (i = start; i < end; ++i) { + c = PyUnicode_READ_CHAR(object, i); + *outp++ = '\\'; + if (c >= 0x00010000) { + *outp++ = 'U'; + *outp++ = Py_hexdigits[(c>>28)&0xf]; + *outp++ = Py_hexdigits[(c>>24)&0xf]; + *outp++ = Py_hexdigits[(c>>20)&0xf]; + *outp++ = Py_hexdigits[(c>>16)&0xf]; + *outp++ = Py_hexdigits[(c>>12)&0xf]; + *outp++ = Py_hexdigits[(c>>8)&0xf]; + } + else if (c >= 0x100) { + *outp++ = 'u'; + *outp++ = Py_hexdigits[(c>>12)&0xf]; + *outp++ = Py_hexdigits[(c>>8)&0xf]; + } + else + *outp++ = 'x'; + *outp++ = Py_hexdigits[(c>>4)&0xf]; + *outp++ = Py_hexdigits[c&0xf]; + } + + assert(_PyUnicode_CheckConsistency(res, 1)); + Py_DECREF(object); + return Py_BuildValue("(Nn)", res, end); +} + +static _PyUnicode_Name_CAPI *ucnhash_CAPI = NULL; + +PyObject *PyCodec_NameReplaceErrors(PyObject *exc) +{ if (PyObject_TypeCheck(exc, (PyTypeObject *)PyExc_UnicodeEncodeError)) { PyObject *restuple; PyObject *object; @@ -865,36 +978,56 @@ PyObject *PyCodec_BackslashReplaceErrors(PyObject *exc) PyObject *res; unsigned char *outp; Py_ssize_t ressize; + int replsize; Py_UCS4 c; + char buffer[256]; /* NAME_MAXLEN */ if (PyUnicodeEncodeError_GetStart(exc, &start)) return NULL; if (PyUnicodeEncodeError_GetEnd(exc, &end)) return NULL; if (!(object = PyUnicodeEncodeError_GetObject(exc))) return NULL; - if (end - start > PY_SSIZE_T_MAX / (1+1+8)) - end = start + PY_SSIZE_T_MAX / (1+1+8); + if (!ucnhash_CAPI) { + /* load the unicode data module */ + ucnhash_CAPI = (_PyUnicode_Name_CAPI *)PyCapsule_Import( + PyUnicodeData_CAPSULE_NAME, 1); + if (!ucnhash_CAPI) + return NULL; + } for (i = start, ressize = 0; i < end; ++i) { /* object is guaranteed to be "ready" */ c = PyUnicode_READ_CHAR(object, i); - if (c >= 0x10000) { - ressize += 1+1+8; + if (ucnhash_CAPI->getname(NULL, c, buffer, sizeof(buffer), 1)) { + replsize = 1+1+1+(int)strlen(buffer)+1; + } + else if (c >= 0x10000) { + replsize = 1+1+8; } else if (c >= 0x100) { - ressize += 1+1+4; + replsize = 1+1+4; } else - ressize += 1+1+2; + replsize = 1+1+2; + if (ressize > PY_SSIZE_T_MAX - replsize) + break; + ressize += replsize; } + end = i; res = PyUnicode_New(ressize, 127); - if (res == NULL) { - Py_DECREF(object); + if (res==NULL) return NULL; - } for (i = start, outp = PyUnicode_1BYTE_DATA(res); i < end; ++i) { c = PyUnicode_READ_CHAR(object, i); *outp++ = '\\'; + if (ucnhash_CAPI->getname(NULL, c, buffer, sizeof(buffer), 1)) { + *outp++ = 'N'; + *outp++ = '{'; + strcpy((char *)outp, buffer); + outp += strlen(buffer); + *outp++ = '}'; + continue; + } if (c >= 0x00010000) { *outp++ = 'U'; *outp++ = Py_hexdigits[(c>>28)&0xf]; @@ -915,6 +1048,7 @@ PyObject *PyCodec_BackslashReplaceErrors(PyObject *exc) *outp++ = Py_hexdigits[c&0xf]; } + assert(outp == PyUnicode_1BYTE_DATA(res) + ressize); assert(_PyUnicode_CheckConsistency(res, 1)); restuple = Py_BuildValue("(Nn)", res, end); Py_DECREF(object); @@ -926,6 +1060,7 @@ PyObject *PyCodec_BackslashReplaceErrors(PyObject *exc) } } +#define ENC_UNKNOWN -1 #define ENC_UTF8 0 #define ENC_UTF16BE 1 #define ENC_UTF16LE 2 @@ -941,7 +1076,11 @@ get_standard_encoding(const char *encoding, int *bytelength) encoding += 3; if (*encoding == '-' || *encoding == '_' ) encoding++; - if (encoding[0] == '1' && encoding[1] == '6') { + if (encoding[0] == '8' && encoding[1] == '\0') { + *bytelength = 3; + return ENC_UTF8; + } + else if (encoding[0] == '1' && encoding[1] == '6') { encoding += 2; *bytelength = 2; if (*encoding == '\0') { @@ -980,9 +1119,11 @@ get_standard_encoding(const char *encoding, int *bytelength) } } } - /* utf-8 */ - *bytelength = 3; - return ENC_UTF8; + else if (strcmp(encoding, "CP_UTF8") == 0) { + *bytelength = 3; + return ENC_UTF8; + } + return ENC_UNKNOWN; } /* This handler is declared static until someone demonstrates @@ -1020,6 +1161,12 @@ PyCodec_SurrogatePassErrors(PyObject *exc) } code = get_standard_encoding(encoding, &bytelength); Py_DECREF(encode); + if (code == ENC_UNKNOWN) { + /* Not supported, fail with original exception */ + PyErr_SetObject(PyExceptionInstance_Class(exc), exc); + Py_DECREF(object); + return NULL; + } if (end - start > PY_SSIZE_T_MAX / bytelength) end = start + PY_SSIZE_T_MAX / bytelength; @@ -1096,6 +1243,12 @@ PyCodec_SurrogatePassErrors(PyObject *exc) } code = get_standard_encoding(encoding, &bytelength); Py_DECREF(encode); + if (code == ENC_UNKNOWN) { + /* Not supported, fail with original exception */ + PyErr_SetObject(PyExceptionInstance_Class(exc), exc); + Py_DECREF(object); + return NULL; + } /* Try decoding a single surrogate character. If there are more, let the codec call us again. */ @@ -1252,6 +1405,11 @@ static PyObject *backslashreplace_errors(PyObject *self, PyObject *exc) return PyCodec_BackslashReplaceErrors(exc); } +static PyObject *namereplace_errors(PyObject *self, PyObject *exc) +{ + return PyCodec_NameReplaceErrors(exc); +} + static PyObject *surrogatepass_errors(PyObject *self, PyObject *exc) { return PyCodec_SurrogatePassErrors(exc); @@ -1317,8 +1475,19 @@ static int _PyCodecRegistry_Init(void) backslashreplace_errors, METH_O, PyDoc_STR("Implements the 'backslashreplace' error handling, " + "which replaces malformed data with a backslashed " + "escape sequence.") + } + }, + { + "namereplace", + { + "namereplace_errors", + namereplace_errors, + METH_O, + PyDoc_STR("Implements the 'namereplace' error handling, " "which replaces an unencodable character with a " - "backslashed escape sequence.") + "\\N{...} escape sequence.") } }, { diff --git a/Python/compile.c b/Python/compile.c index ff6248782b..4befaa78fc 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -30,8 +30,6 @@ #include "symtable.h" #include "opcode.h" -int Py_OptimizeFlag = 0; - #define DEFAULT_BLOCK_SIZE 16 #define DEFAULT_BLOCKS 8 #define DEFAULT_CODE_SIZE 128 @@ -94,6 +92,7 @@ enum { COMPILER_SCOPE_MODULE, COMPILER_SCOPE_CLASS, COMPILER_SCOPE_FUNCTION, + COMPILER_SCOPE_ASYNC_FUNCTION, COMPILER_SCOPE_LAMBDA, COMPILER_SCOPE_COMPREHENSION, }; @@ -195,11 +194,11 @@ static int inplace_binop(struct compiler *, operator_ty); static int expr_constant(struct compiler *, expr_ty); static int compiler_with(struct compiler *, stmt_ty, int); +static int compiler_async_with(struct compiler *, stmt_ty, int); +static int compiler_async_for(struct compiler *, stmt_ty); 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 *); @@ -677,7 +676,9 @@ compiler_set_qualname(struct compiler *c) parent = (struct compiler_unit *)PyCapsule_GetPointer(capsule, CAPSULE_NAME); 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_ASYNC_FUNCTION + || u->u_scope_type == COMPILER_SCOPE_CLASS) { assert(u->u_name); mangled = _Py_Mangle(parent->u_private, u->u_name); if (!mangled) @@ -691,6 +692,7 @@ compiler_set_qualname(struct compiler *c) if (!force_global) { if (parent->u_scope_type == COMPILER_SCOPE_FUNCTION + || parent->u_scope_type == COMPILER_SCOPE_ASYNC_FUNCTION || parent->u_scope_type == COMPILER_SCOPE_LAMBDA) { dot_locals_str = _PyUnicode_FromId(&dot_locals); if (dot_locals_str == NULL) @@ -881,6 +883,7 @@ PyCompile_OpcodeStackEffect(int opcode, int oparg) case BINARY_POWER: case BINARY_MULTIPLY: + case BINARY_MATRIX_MULTIPLY: case BINARY_MODULO: case BINARY_ADD: case BINARY_SUBTRACT: @@ -895,12 +898,11 @@ PyCompile_OpcodeStackEffect(int opcode, int oparg) case INPLACE_ADD: case INPLACE_SUBTRACT: case INPLACE_MULTIPLY: + case INPLACE_MATRIX_MULTIPLY: case INPLACE_MODULO: return -1; case STORE_SUBSCR: return -3; - case STORE_MAP: - return -2; case DELETE_SUBSCR: return -2; @@ -929,7 +931,9 @@ PyCompile_OpcodeStackEffect(int opcode, int oparg) return 0; case SETUP_WITH: return 7; - case WITH_CLEANUP: + case WITH_CLEANUP_START: + return 1; + case WITH_CLEANUP_FINISH: return -1; /* XXX Sometimes more */ case RETURN_VALUE: return -1; @@ -973,8 +977,15 @@ PyCompile_OpcodeStackEffect(int opcode, int oparg) 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; + return 1 - 2*oparg; case LOAD_ATTR: return 0; case COMPARE_OP: @@ -1043,6 +1054,18 @@ PyCompile_OpcodeStackEffect(int opcode, int oparg) return -1; case DELETE_DEREF: return 0; + case GET_AWAITABLE: + return 0; + case SETUP_ASYNC_WITH: + return 6; + case BEFORE_ASYNC_WITH: + return 1; + case GET_AITER: + return 0; + case GET_ANEXT: + return 1; + case GET_YIELD_FROM_ITER: + return 0; default: return PY_INVALID_STACK_EFFECT; } @@ -1123,8 +1146,10 @@ compiler_add_o(struct compiler *c, PyObject *dict, PyObject *o) v = PyDict_GetItem(dict, t); if (!v) { - if (PyErr_Occurred()) + if (PyErr_Occurred()) { + Py_DECREF(t); return -1; + } arg = PyDict_Size(dict); v = PyLong_FromSsize_t(arg); if (!v) { @@ -1536,32 +1561,31 @@ compiler_visit_argannotation(struct compiler *c, identifier id, VISIT(c, expr, annotation); mangled = _Py_Mangle(c->u->u_private, id); if (!mangled) - return -1; + return 0; if (PyList_Append(names, mangled) < 0) { Py_DECREF(mangled); - return -1; + return 0; } Py_DECREF(mangled); } - return 0; + return 1; } static int compiler_visit_argannotations(struct compiler *c, asdl_seq* args, PyObject *names) { - int i, error; + int i; for (i = 0; i < asdl_seq_LEN(args); i++) { arg_ty arg = (arg_ty)asdl_seq_GET(args, i); - error = compiler_visit_argannotation( + if (!compiler_visit_argannotation( c, arg->arg, arg->annotation, - names); - if (error) - return error; + names)) + return 0; } - return 0; + return 1; } static int @@ -1581,16 +1605,16 @@ compiler_visit_annotations(struct compiler *c, arguments_ty args, if (!names) return -1; - if (compiler_visit_argannotations(c, args->args, names)) + if (!compiler_visit_argannotations(c, args->args, names)) goto error; if (args->vararg && args->vararg->annotation && - compiler_visit_argannotation(c, args->vararg->arg, + !compiler_visit_argannotation(c, args->vararg->arg, args->vararg->annotation, names)) goto error; - if (compiler_visit_argannotations(c, args->kwonlyargs, names)) + if (!compiler_visit_argannotations(c, args->kwonlyargs, names)) goto error; if (args->kwarg && args->kwarg->annotation && - compiler_visit_argannotation(c, args->kwarg->arg, + !compiler_visit_argannotation(c, args->kwarg->arg, args->kwarg->annotation, names)) goto error; @@ -1599,7 +1623,7 @@ compiler_visit_annotations(struct compiler *c, arguments_ty args, if (!return_str) goto error; } - if (compiler_visit_argannotation(c, return_str, returns, names)) { + if (!compiler_visit_argannotation(c, return_str, returns, names)) { goto error; } @@ -1637,19 +1661,43 @@ error: } static int -compiler_function(struct compiler *c, stmt_ty s) +compiler_function(struct compiler *c, stmt_ty s, int is_async) { PyCodeObject *co; PyObject *qualname, *first_const = Py_None; - arguments_ty args = s->v.FunctionDef.args; - expr_ty returns = s->v.FunctionDef.returns; - asdl_seq* decos = s->v.FunctionDef.decorator_list; + arguments_ty args; + expr_ty returns; + identifier name; + asdl_seq* decos; + asdl_seq *body; stmt_ty st; Py_ssize_t i, n, arglength; int docstring, kw_default_count = 0; int num_annotations; + int scope_type; + + + if (is_async) { + assert(s->kind == AsyncFunctionDef_kind); - assert(s->kind == FunctionDef_kind); + args = s->v.AsyncFunctionDef.args; + returns = s->v.AsyncFunctionDef.returns; + decos = s->v.AsyncFunctionDef.decorator_list; + name = s->v.AsyncFunctionDef.name; + body = s->v.AsyncFunctionDef.body; + + scope_type = COMPILER_SCOPE_ASYNC_FUNCTION; + } else { + assert(s->kind == FunctionDef_kind); + + args = s->v.FunctionDef.args; + returns = s->v.FunctionDef.returns; + decos = s->v.FunctionDef.decorator_list; + name = s->v.FunctionDef.name; + body = s->v.FunctionDef.body; + + scope_type = COMPILER_SCOPE_FUNCTION; + } if (!compiler_decorators(c, decos)) return 0; @@ -1667,12 +1715,12 @@ compiler_function(struct compiler *c, stmt_ty s) return 0; assert((num_annotations & 0xFFFF) == num_annotations); - if (!compiler_enter_scope(c, s->v.FunctionDef.name, - COMPILER_SCOPE_FUNCTION, (void *)s, + if (!compiler_enter_scope(c, name, + scope_type, (void *)s, s->lineno)) return 0; - st = (stmt_ty)asdl_seq_GET(s->v.FunctionDef.body, 0); + st = (stmt_ty)asdl_seq_GET(body, 0); docstring = compiler_isdocstring(st); if (docstring && c->c_optimize < 2) first_const = st->v.Expr.value->v.Str.s; @@ -1683,10 +1731,10 @@ compiler_function(struct compiler *c, stmt_ty s) c->u->u_argcount = asdl_seq_LEN(args->args); c->u->u_kwonlyargcount = asdl_seq_LEN(args->kwonlyargs); - n = asdl_seq_LEN(s->v.FunctionDef.body); + n = asdl_seq_LEN(body); /* if there was a docstring, we need to skip the first statement */ for (i = docstring; i < n; i++) { - st = (stmt_ty)asdl_seq_GET(s->v.FunctionDef.body, i); + st = (stmt_ty)asdl_seq_GET(body, i); VISIT_IN_SCOPE(c, stmt, st); } co = assemble(c, 1); @@ -1702,6 +1750,8 @@ compiler_function(struct compiler *c, stmt_ty s) arglength = asdl_seq_LEN(args->defaults); arglength |= kw_default_count << 8; arglength |= num_annotations << 16; + if (is_async) + co->co_flags |= CO_COROUTINE; compiler_make_closure(c, co, arglength, qualname); Py_DECREF(qualname); Py_DECREF(co); @@ -1711,7 +1761,7 @@ compiler_function(struct compiler *c, stmt_ty s) ADDOP_I(c, CALL_FUNCTION, 1); } - return compiler_nameop(c, s->v.FunctionDef.name, Store); + return compiler_nameop(c, name, Store); } static int @@ -1821,9 +1871,7 @@ compiler_class(struct compiler *c, stmt_ty s) /* 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 */ @@ -1938,7 +1986,7 @@ compiler_if(struct compiler *c, stmt_ty s) } else if (constant == 1) { VISIT_SEQ(c, stmt, s->v.If.body); } else { - if (s->v.If.orelse) { + if (asdl_seq_LEN(s->v.If.orelse)) { next = compiler_new_block(c); if (next == NULL) return 0; @@ -1948,8 +1996,8 @@ compiler_if(struct compiler *c, stmt_ty s) VISIT(c, expr, s->v.If.test); ADDOP_JABS(c, POP_JUMP_IF_FALSE, next); VISIT_SEQ(c, stmt, s->v.If.body); - ADDOP_JREL(c, JUMP_FORWARD, end); - if (s->v.If.orelse) { + if (asdl_seq_LEN(s->v.If.orelse)) { + ADDOP_JREL(c, JUMP_FORWARD, end); compiler_use_next_block(c, next); VISIT_SEQ(c, stmt, s->v.If.orelse); } @@ -1986,6 +2034,92 @@ compiler_for(struct compiler *c, stmt_ty s) return 1; } + +static int +compiler_async_for(struct compiler *c, stmt_ty s) +{ + static PyObject *stopiter_error = NULL; + basicblock *try, *except, *end, *after_try, *try_cleanup, + *after_loop, *after_loop_else; + + if (stopiter_error == NULL) { + stopiter_error = PyUnicode_InternFromString("StopAsyncIteration"); + if (stopiter_error == NULL) + return 0; + } + + try = compiler_new_block(c); + except = compiler_new_block(c); + end = compiler_new_block(c); + after_try = compiler_new_block(c); + try_cleanup = compiler_new_block(c); + after_loop = compiler_new_block(c); + after_loop_else = compiler_new_block(c); + + if (try == NULL || except == NULL || end == NULL + || after_try == NULL || try_cleanup == NULL) + return 0; + + ADDOP_JREL(c, SETUP_LOOP, after_loop); + if (!compiler_push_fblock(c, LOOP, try)) + return 0; + + VISIT(c, expr, s->v.AsyncFor.iter); + ADDOP(c, GET_AITER); + ADDOP_O(c, LOAD_CONST, Py_None, consts); + ADDOP(c, YIELD_FROM); + + compiler_use_next_block(c, try); + + + ADDOP_JREL(c, SETUP_EXCEPT, except); + if (!compiler_push_fblock(c, EXCEPT, try)) + return 0; + + ADDOP(c, GET_ANEXT); + ADDOP_O(c, LOAD_CONST, Py_None, consts); + ADDOP(c, YIELD_FROM); + VISIT(c, expr, s->v.AsyncFor.target); + ADDOP(c, POP_BLOCK); + compiler_pop_fblock(c, EXCEPT, try); + ADDOP_JREL(c, JUMP_FORWARD, after_try); + + + compiler_use_next_block(c, except); + ADDOP(c, DUP_TOP); + ADDOP_O(c, LOAD_GLOBAL, stopiter_error, names); + ADDOP_I(c, COMPARE_OP, PyCmp_EXC_MATCH); + ADDOP_JABS(c, POP_JUMP_IF_FALSE, try_cleanup); + + ADDOP(c, POP_TOP); + ADDOP(c, POP_TOP); + ADDOP(c, POP_TOP); + ADDOP(c, POP_EXCEPT); /* for SETUP_EXCEPT */ + ADDOP(c, POP_BLOCK); /* for SETUP_LOOP */ + ADDOP_JABS(c, JUMP_ABSOLUTE, after_loop_else); + + + compiler_use_next_block(c, try_cleanup); + ADDOP(c, END_FINALLY); + + compiler_use_next_block(c, after_try); + VISIT_SEQ(c, stmt, s->v.AsyncFor.body); + ADDOP_JABS(c, JUMP_ABSOLUTE, try); + + ADDOP(c, POP_BLOCK); /* for SETUP_LOOP */ + compiler_pop_fblock(c, LOOP, try); + + compiler_use_next_block(c, after_loop); + ADDOP_JABS(c, JUMP_ABSOLUTE, end); + + compiler_use_next_block(c, after_loop_else); + VISIT_SEQ(c, stmt, s->v.For.orelse); + + compiler_use_next_block(c, end); + + return 1; +} + static int compiler_while(struct compiler *c, stmt_ty s) { @@ -2512,7 +2646,7 @@ compiler_visit_stmt(struct compiler *c, stmt_ty s) switch (s->kind) { case FunctionDef_kind: - return compiler_function(c, s); + return compiler_function(c, s, 0); case ClassDef_kind: return compiler_class(c, s); case Return_kind: @@ -2591,7 +2725,14 @@ compiler_visit_stmt(struct compiler *c, stmt_ty s) return compiler_continue(c); case With_kind: return compiler_with(c, s, 0); + case AsyncFunctionDef_kind: + return compiler_function(c, s, 1); + case AsyncWith_kind: + return compiler_async_with(c, s, 0); + case AsyncFor_kind: + return compiler_async_for(c, s); } + return 1; } @@ -2624,6 +2765,8 @@ binop(struct compiler *c, operator_ty op) return BINARY_SUBTRACT; case Mult: return BINARY_MULTIPLY; + case MatMult: + return BINARY_MATRIX_MULTIPLY; case Div: return BINARY_TRUE_DIVIDE; case Mod: @@ -2688,6 +2831,8 @@ inplace_binop(struct compiler *c, operator_ty op) return INPLACE_SUBTRACT; case Mult: return INPLACE_MULTIPLY; + case MatMult: + return INPLACE_MATRIX_MULTIPLY; case Div: return INPLACE_TRUE_DIVIDE; case Mod: @@ -2749,8 +2894,7 @@ compiler_nameop(struct compiler *c, identifier name, expr_context_ty ctx) optype = OP_FAST; break; case GLOBAL_IMPLICIT: - if (c->u->u_ste->ste_type == FunctionBlock && - !c->u->u_ste->ste_unoptimized) + if (c->u->u_ste->ste_type == FunctionBlock) optype = OP_GLOBAL; break; case GLOBAL_EXPLICIT: @@ -2868,67 +3012,145 @@ compiler_boolop(struct compiler *c, expr_ty e) } static int -compiler_list(struct compiler *c, expr_ty e) +starunpack_helper(struct compiler *c, asdl_seq *elts, + int single_op, int inner_op, int outer_op) { - Py_ssize_t n = asdl_seq_LEN(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"); + 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++; } - if (!seen_star) { - ADDOP_I(c, UNPACK_SEQUENCE, n); + else { + VISIT(c, expr, elt); + nseen++; } } - VISIT_SEQ(c, expr, e->v.List.elts); - if (e->v.List.ctx == Load) { - ADDOP_I(c, BUILD_LIST, n); + 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) +{ + asdl_seq *elts = e->v.List.elts; + if (e->v.List.ctx == Store) { + return assignment_helper(c, elts); + } + 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.keys, i)); + VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Dict.values, 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; } @@ -2984,9 +3206,7 @@ compiler_call(struct compiler *c, expr_ty e) 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 */ @@ -2994,26 +3214,102 @@ static int 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 (nseen) { + /* Pack up any trailing positional arguments. */ + ADDOP_I(c, BUILD_TUPLE, nseen); + nsubargs++; } - if (starargs) { - VISIT(c, expr, starargs); + 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. */ + ADDOP_O(c, LOAD_CONST, kw->arg, consts); + VISIT(c, expr, kw->value); + 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); @@ -3138,8 +3434,9 @@ compiler_comprehension_generator(struct compiler *c, } 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; @@ -3312,6 +3609,102 @@ expr_constant(struct compiler *c, expr_ty e) } } + +/* + Implements the async with statement. + + The semantics outlined in that PEP are as follows: + + async with EXPR as VAR: + BLOCK + + It is implemented roughly as: + + context = EXPR + exit = context.__aexit__ # not calling it + value = await context.__aenter__() + try: + VAR = value # if VAR present in the syntax + BLOCK + finally: + if an exception was raised: + exc = copy of (exception, instance, traceback) + else: + exc = (None, None, None) + if not (await exit(*exc)): + raise + */ +static int +compiler_async_with(struct compiler *c, stmt_ty s, int pos) +{ + basicblock *block, *finally; + withitem_ty item = asdl_seq_GET(s->v.AsyncWith.items, pos); + + assert(s->kind == AsyncWith_kind); + + block = compiler_new_block(c); + finally = compiler_new_block(c); + if (!block || !finally) + return 0; + + /* Evaluate EXPR */ + VISIT(c, expr, item->context_expr); + + ADDOP(c, BEFORE_ASYNC_WITH); + ADDOP(c, GET_AWAITABLE); + ADDOP_O(c, LOAD_CONST, Py_None, consts); + ADDOP(c, YIELD_FROM); + + ADDOP_JREL(c, SETUP_ASYNC_WITH, finally); + + /* SETUP_ASYNC_WITH pushes a finally block. */ + compiler_use_next_block(c, block); + if (!compiler_push_fblock(c, FINALLY_TRY, block)) { + return 0; + } + + if (item->optional_vars) { + VISIT(c, expr, item->optional_vars); + } + else { + /* Discard result from context.__aenter__() */ + ADDOP(c, POP_TOP); + } + + pos++; + if (pos == asdl_seq_LEN(s->v.AsyncWith.items)) + /* BLOCK code */ + VISIT_SEQ(c, stmt, s->v.AsyncWith.body) + else if (!compiler_async_with(c, s, pos)) + return 0; + + /* End of try block; start the finally block */ + ADDOP(c, POP_BLOCK); + compiler_pop_fblock(c, FINALLY_TRY, block); + + ADDOP_O(c, LOAD_CONST, Py_None, consts); + compiler_use_next_block(c, finally); + if (!compiler_push_fblock(c, FINALLY_END, finally)) + return 0; + + /* Finally block starts; context.__exit__ is on the stack under + the exception or return information. Just issue our magic + opcode. */ + ADDOP(c, WITH_CLEANUP_START); + + ADDOP(c, GET_AWAITABLE); + ADDOP_O(c, LOAD_CONST, Py_None, consts); + ADDOP(c, YIELD_FROM); + + ADDOP(c, WITH_CLEANUP_FINISH); + + /* Finally block ends. */ + ADDOP(c, END_FINALLY); + compiler_pop_fblock(c, FINALLY_END, finally); + return 1; +} + + /* Implements the with statement from PEP 343. @@ -3385,7 +3778,8 @@ compiler_with(struct compiler *c, stmt_ty s, int pos) /* Finally block starts; context.__exit__ is on the stack under the exception or return information. Just issue our magic opcode. */ - ADDOP(c, WITH_CLEANUP); + ADDOP(c, WITH_CLEANUP_START); + ADDOP(c, WITH_CLEANUP_FINISH); /* Finally block ends. */ ADDOP(c, END_FINALLY); @@ -3396,8 +3790,6 @@ compiler_with(struct compiler *c, stmt_ty s, int pos) 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. */ @@ -3424,23 +3816,9 @@ compiler_visit_expr(struct compiler *c, expr_ty e) 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: @@ -3452,6 +3830,8 @@ compiler_visit_expr(struct compiler *c, expr_ty e) case Yield_kind: if (c->u->u_ste->ste_type != FunctionBlock) return compiler_error(c, "'yield' outside function"); + if (c->u->u_scope_type == COMPILER_SCOPE_ASYNC_FUNCTION) + return compiler_error(c, "'yield' inside async function"); if (e->v.Yield.value) { VISIT(c, expr, e->v.Yield.value); } @@ -3463,8 +3843,28 @@ compiler_visit_expr(struct compiler *c, expr_ty e) case YieldFrom_kind: if (c->u->u_ste->ste_type != FunctionBlock) return compiler_error(c, "'yield' outside function"); + + if (c->u->u_scope_type == COMPILER_SCOPE_ASYNC_FUNCTION) + return compiler_error(c, "'yield from' inside async function"); + VISIT(c, expr, e->v.YieldFrom.value); - ADDOP(c, GET_ITER); + ADDOP(c, GET_YIELD_FROM_ITER); + ADDOP_O(c, LOAD_CONST, Py_None, consts); + ADDOP(c, YIELD_FROM); + break; + case Await_kind: + if (c->u->u_ste->ste_type != FunctionBlock) + return compiler_error(c, "'await' outside function"); + + if (c->u->u_scope_type == COMPILER_SCOPE_COMPREHENSION) + return compiler_error( + c, "'await' expressions in comprehensions are not supported"); + + if (c->u->u_scope_type != COMPILER_SCOPE_ASYNC_FUNCTION) + return compiler_error(c, "'await' outside async function"); + + VISIT(c, expr, e->v.Await.value); + ADDOP(c, GET_AWAITABLE); ADDOP_O(c, LOAD_CONST, Py_None, consts); ADDOP(c, YIELD_FROM); break; @@ -3551,7 +3951,7 @@ compiler_visit_expr(struct compiler *c, expr_ty e) "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: @@ -4181,9 +4581,7 @@ compute_code_flags(struct compiler *c) int flags = 0; Py_ssize_t n; if (ste->ste_type == FunctionBlock) { - flags |= CO_NEWLOCALS; - if (!ste->ste_unoptimized) - flags |= CO_OPTIMIZED; + flags |= CO_NEWLOCALS | CO_OPTIMIZED; if (ste->ste_nested) flags |= CO_NESTED; if (ste->ste_generator) diff --git a/Python/condvar.h b/Python/condvar.h index ef818c4d4b..bb5b1b661f 100644 --- a/Python/condvar.h +++ b/Python/condvar.h @@ -1,4 +1,4 @@ -/* +/* * Portable condition variable support for windows and pthreads. * Everything is inline, this header can be included where needed. * @@ -105,7 +105,7 @@ PyCOND_TIMEDWAIT(PyCOND_T *cond, PyMUTEX_T *mut, PY_LONG_LONG us) return 1; else if (r) return -1; - else + else return 0; } @@ -255,7 +255,7 @@ _PyCOND_WAIT_MS(PyCOND_T *cv, PyMUTEX_T *cs, DWORD ms) * a new thread comes along, it will pass right throuhgh, having * adjusted it to (waiting == 0 && sem.count == 0). */ - + if (wait == WAIT_FAILED) return -1; /* return 0 on success, 1 on timeout */ diff --git a/Python/dtoa.c b/Python/dtoa.c index 8996a7210c..3da546ed07 100644 --- a/Python/dtoa.c +++ b/Python/dtoa.c @@ -373,7 +373,7 @@ Balloc(int k) x = 1 << k; len = (sizeof(Bigint) + (x-1)*sizeof(ULong) + sizeof(double) - 1) /sizeof(double); - if (k <= Kmax && pmem_next - private_mem + len <= PRIVATE_mem) { + if (k <= Kmax && pmem_next - private_mem + len <= (Py_ssize_t)PRIVATE_mem) { rv = (Bigint*)pmem_next; pmem_next += len; } @@ -1087,7 +1087,7 @@ sd2b(U *d, int scale, int *e) b = Balloc(1); if (b == NULL) return NULL; - + /* First construct b and e assuming that scale == 0. */ b->wds = 2; b->x[0] = word1(d); diff --git a/Python/dynload_aix.c b/Python/dynload_aix.c index 5ac30ed5f1..b3ff8e288c 100644 --- a/Python/dynload_aix.c +++ b/Python/dynload_aix.c @@ -154,8 +154,9 @@ aix_loaderror(const char *pathname) } -dl_funcptr _PyImport_GetDynLoadFunc(const char *shortname, - const char *pathname, FILE *fp) +dl_funcptr _PyImport_FindSharedFuncptr(const char *prefix, + const char *shortname, + const char *pathname, FILE *fp) { dl_funcptr p; diff --git a/Python/dynload_dl.c b/Python/dynload_dl.c index 5836cb3b29..2bec645fbd 100644 --- a/Python/dynload_dl.c +++ b/Python/dynload_dl.c @@ -12,11 +12,12 @@ extern char *Py_GetProgramName(void); const char *_PyImport_DynLoadFiletab[] = {".o", NULL}; -dl_funcptr _PyImport_GetDynLoadFunc(const char *shortname, - const char *pathname, FILE *fp) +dl_funcptr _PyImport_FindSharedFuncptr(const char *prefix, + const char *shortname, + const char *pathname, FILE *fp) { char funcname[258]; - PyOS_snprintf(funcname, sizeof(funcname), "PyInit_%.200s", shortname); + PyOS_snprintf(funcname, sizeof(funcname), "%.20s_%.200s", prefix, shortname); return dl_loadmod(Py_GetProgramName(), pathname, funcname); } diff --git a/Python/dynload_hpux.c b/Python/dynload_hpux.c index c9554148cc..4967afc39c 100644 --- a/Python/dynload_hpux.c +++ b/Python/dynload_hpux.c @@ -8,15 +8,16 @@ #include "importdl.h" #if defined(__hp9000s300) -#define FUNCNAME_PATTERN "_PyInit_%.200s" +#define FUNCNAME_PATTERN "_%.20s_%.200s" #else -#define FUNCNAME_PATTERN "PyInit_%.200s" +#define FUNCNAME_PATTERN "%.20s_%.200s" #endif const char *_PyImport_DynLoadFiletab[] = {SHLIB_EXT, NULL}; -dl_funcptr _PyImport_GetDynLoadFunc(const char *shortname, - const char *pathname, FILE *fp) +dl_funcptr _PyImport_FindSharedFuncptr(const char *prefix, + const char *shortname, + const char *pathname, FILE *fp) { dl_funcptr p; shl_t lib; @@ -50,7 +51,8 @@ dl_funcptr _PyImport_GetDynLoadFunc(const char *shortname, Py_DECREF(pathname_ob); return NULL; } - PyOS_snprintf(funcname, sizeof(funcname), FUNCNAME_PATTERN, shortname); + PyOS_snprintf(funcname, sizeof(funcname), FUNCNAME_PATTERN, + prefix, shortname); if (Py_VerboseFlag) printf("shl_findsym %s\n", funcname); if (shl_findsym(&lib, funcname, TYPE_UNDEFINED, (void *) &p) == -1) { diff --git a/Python/dynload_next.c b/Python/dynload_next.c index 85c95b41bb..83a8b2bb31 100644 --- a/Python/dynload_next.c +++ b/Python/dynload_next.c @@ -27,8 +27,9 @@ const char *_PyImport_DynLoadFiletab[] = {".so", NULL}; #define LINKOPTIONS NSLINKMODULE_OPTION_BINDNOW| \ NSLINKMODULE_OPTION_RETURN_ON_ERROR|NSLINKMODULE_OPTION_PRIVATE #endif -dl_funcptr _PyImport_GetDynLoadFunc(const char *shortname, - const char *pathname, FILE *fp) +dl_funcptr _PyImport_FindSharedFuncptr(const char *prefix, + const char *shortname, + const char *pathname, FILE *fp) { dl_funcptr p = NULL; char funcname[258]; @@ -39,7 +40,7 @@ dl_funcptr _PyImport_GetDynLoadFunc(const char *shortname, const char *errString; char errBuf[512]; - PyOS_snprintf(funcname, sizeof(funcname), "_PyInit_%.200s", shortname); + PyOS_snprintf(funcname, sizeof(funcname), "_%.20s_%.200s", prefix, shortname); #ifdef USE_DYLD_GLOBAL_NAMESPACE if (NSIsSymbolNameDefined(funcname)) { diff --git a/Python/dynload_shlib.c b/Python/dynload_shlib.c index 5cd1efdf76..7f8f134d60 100644 --- a/Python/dynload_shlib.c +++ b/Python/dynload_shlib.c @@ -51,8 +51,10 @@ static struct { static int nhandles = 0; -dl_funcptr _PyImport_GetDynLoadFunc(const char *shortname, - const char *pathname, FILE *fp) +dl_funcptr +_PyImport_FindSharedFuncptr(const char *prefix, + const char *shortname, + const char *pathname, FILE *fp) { dl_funcptr p; void *handle; @@ -67,26 +69,24 @@ dl_funcptr _PyImport_GetDynLoadFunc(const char *shortname, } PyOS_snprintf(funcname, sizeof(funcname), - LEAD_UNDERSCORE "PyInit_%.200s", shortname); + LEAD_UNDERSCORE "%.20s_%.200s", prefix, shortname); if (fp != NULL) { int i; - struct stat statb; - if (fstat(fileno(fp), &statb) == -1) { - PyErr_SetFromErrno(PyExc_IOError); + struct _Py_stat_struct status; + if (_Py_fstat(fileno(fp), &status) == -1) return NULL; - } for (i = 0; i < nhandles; i++) { - if (statb.st_dev == handles[i].dev && - statb.st_ino == handles[i].ino) { + if (status.st_dev == handles[i].dev && + status.st_ino == handles[i].ino) { p = (dl_funcptr) dlsym(handles[i].handle, funcname); return p; } } if (nhandles < 128) { - handles[nhandles].dev = statb.st_dev; - handles[nhandles].ino = statb.st_ino; + handles[nhandles].dev = status.st_dev; + handles[nhandles].ino = status.st_ino; } } diff --git a/Python/dynload_win.c b/Python/dynload_win.c index ffcf0ee1d7..f2c796e94d 100644 --- a/Python/dynload_win.c +++ b/Python/dynload_win.c @@ -9,6 +9,7 @@ #include <ctype.h> #include "importdl.h" +#include "patchlevel.h" #include <windows.h> // "activation context" magic - see dl_nt.c... @@ -17,16 +18,28 @@ extern ULONG_PTR _Py_ActivateActCtx(); void _Py_DeactivateActCtx(ULONG_PTR cookie); #endif -const char *_PyImport_DynLoadFiletab[] = { #ifdef _DEBUG - "_d.pyd", +#define PYD_DEBUG_SUFFIX "_d" +#else +#define PYD_DEBUG_SUFFIX "" +#endif + +#define STRINGIZE2(x) #x +#define STRINGIZE(x) STRINGIZE2(x) +#ifdef PYD_PLATFORM_TAG +#define PYD_TAGGED_SUFFIX PYD_DEBUG_SUFFIX ".cp" STRINGIZE(PY_MAJOR_VERSION) STRINGIZE(PY_MINOR_VERSION) "-" PYD_PLATFORM_TAG ".pyd" #else - ".pyd", +#define PYD_TAGGED_SUFFIX PYD_DEBUG_SUFFIX ".cp" STRINGIZE(PY_MAJOR_VERSION) STRINGIZE(PY_MINOR_VERSION) ".pyd" #endif + +#define PYD_UNTAGGED_SUFFIX PYD_DEBUG_SUFFIX ".pyd" + +const char *_PyImport_DynLoadFiletab[] = { + PYD_TAGGED_SUFFIX, + PYD_UNTAGGED_SUFFIX, NULL }; - /* Case insensitive string compare, to avoid any dependencies on particular C RTL implementations */ @@ -173,8 +186,9 @@ static char *GetPythonImport (HINSTANCE hModule) return NULL; } -dl_funcptr _PyImport_GetDynLoadWindows(const char *shortname, - PyObject *pathname, FILE *fp) +dl_funcptr _PyImport_FindSharedFuncptrWindows(const char *prefix, + const char *shortname, + PyObject *pathname, FILE *fp) { dl_funcptr p; char funcname[258], *import_python; @@ -188,7 +202,7 @@ dl_funcptr _PyImport_GetDynLoadWindows(const char *shortname, if (wpathname == NULL) return NULL; - PyOS_snprintf(funcname, sizeof(funcname), "PyInit_%.200s", shortname); + PyOS_snprintf(funcname, sizeof(funcname), "%.20s_%.200s", prefix, shortname); { HINSTANCE hDLL = NULL; diff --git a/Python/errors.c b/Python/errors.c index b0ad9aa58b..aed2bdc12d 100644 --- a/Python/errors.c +++ b/Python/errors.c @@ -74,11 +74,11 @@ PyErr_SetObject(PyObject *exception, PyObject *value) if (value == NULL || !PyExceptionInstance_Check(value)) { /* We must normalize the value right now */ PyObject *args, *fixed_value; -#ifdef Py_DEBUG - /* in debug mode, PyEval_EvalFrameEx() fails with an assertion - error if an exception is set when it is called */ + + /* Issue #23571: PyEval_CallObject() must not be called with an + exception set */ PyErr_Clear(); -#endif + if (value == NULL || value == Py_None) args = PyTuple_New(0); else if (PyTuple_Check(value)) { @@ -319,7 +319,7 @@ finally: Py_DECREF(*exc); Py_DECREF(*val); /* ... and use the recursion error instead */ - *exc = PyExc_RuntimeError; + *exc = PyExc_RecursionError; *val = PyExc_RecursionErrorInst; Py_INCREF(*exc); Py_INCREF(*val); @@ -773,34 +773,38 @@ PyErr_BadInternalCall(void) #define PyErr_BadInternalCall() _PyErr_BadInternalCall(__FILE__, __LINE__) +PyObject * +PyErr_FormatV(PyObject *exception, const char *format, va_list vargs) +{ + PyObject* string; + + /* Issue #23571: PyUnicode_FromFormatV() must not be called with an + exception set, it calls arbitrary Python code like PyObject_Repr() */ + PyErr_Clear(); + + string = PyUnicode_FromFormatV(format, vargs); + + PyErr_SetObject(exception, string); + Py_XDECREF(string); + return NULL; +} + PyObject * PyErr_Format(PyObject *exception, const char *format, ...) { va_list vargs; - PyObject* string; - #ifdef HAVE_STDARG_PROTOTYPES va_start(vargs, format); #else va_start(vargs); #endif - -#ifdef Py_DEBUG - /* in debug mode, PyEval_EvalFrameEx() fails with an assertion error - if an exception is set when it is called */ - PyErr_Clear(); -#endif - - string = PyUnicode_FromFormatV(format, vargs); - PyErr_SetObject(exception, string); - Py_XDECREF(string); + PyErr_FormatV(exception, format, vargs); va_end(vargs); return NULL; } - PyObject * PyErr_NewException(const char *name, PyObject *base, PyObject *dict) { @@ -1121,6 +1125,10 @@ PyErr_ProgramTextObject(PyObject *filename, int lineno) if (filename == NULL || lineno <= 0) return NULL; fp = _Py_fopen_obj(filename, "r" PY_STDIOTEXTMODE); + if (fp == NULL) { + PyErr_Clear(); + return NULL; + } return err_programtext(fp, lineno); } diff --git a/Python/fileutils.c b/Python/fileutils.c index 31689c047b..079918c4a3 100644 --- a/Python/fileutils.c +++ b/Python/fileutils.c @@ -3,7 +3,9 @@ #include <locale.h> #ifdef MS_WINDOWS +# include <malloc.h> # include <windows.h> +extern int winerror_to_errno(int); #endif #ifdef HAVE_LANGINFO_H @@ -29,7 +31,8 @@ extern wchar_t* _Py_DecodeUTF8_surrogateescape(const char *s, Py_ssize_t size); 0: open() ignores O_CLOEXEC flag, ex: Linux kernel older than 2.6.23 1: open() supports O_CLOEXEC flag, close-on-exec is set - The flag is used by _Py_open(), io.FileIO and os.open() */ + The flag is used by _Py_open(), _Py_open_noraise(), io.FileIO + and os.open(). */ int _Py_open_cloexec_works = -1; #endif @@ -39,9 +42,13 @@ _Py_device_encoding(int fd) #if defined(MS_WINDOWS) UINT cp; #endif - if (!_PyVerify_fd(fd) || !isatty(fd)) { + int valid; + _Py_BEGIN_SUPPRESS_IPH + valid = _PyVerify_fd(fd) && isatty(fd); + _Py_END_SUPPRESS_IPH + if (!valid) Py_RETURN_NONE; - } + #if defined(MS_WINDOWS) if (fd == 0) cp = GetConsoleCP(); @@ -82,11 +89,11 @@ extern int _Py_normalize_encoding(const char *, char *, size_t); Values of force_ascii: - 1: the workaround is used: _Py_wchar2char() uses - encode_ascii_surrogateescape() and _Py_char2wchar() uses + 1: the workaround is used: Py_EncodeLocale() uses + encode_ascii_surrogateescape() and Py_DecodeLocale() uses decode_ascii_surrogateescape() - 0: the workaround is not used: _Py_wchar2char() uses wcstombs() and - _Py_char2wchar() uses mbstowcs() + 0: the workaround is not used: Py_EncodeLocale() uses wcstombs() and + Py_DecodeLocale() uses mbstowcs() -1: unknown, need to call check_force_ascii() to get the value */ static int force_ascii = -1; @@ -244,24 +251,26 @@ decode_ascii_surrogateescape(const char *arg, size_t *size) /* Decode a byte string from the locale encoding with the - surrogateescape error handler (undecodable bytes are decoded as characters - in range U+DC80..U+DCFF). If a byte sequence can be decoded as a surrogate + surrogateescape error handler: undecodable bytes are decoded as characters + in range U+DC80..U+DCFF. If a byte sequence can be decoded as a surrogate character, escape the bytes using the surrogateescape error handler instead of decoding them. - Use _Py_wchar2char() to encode the character string back to a byte string. + Return a pointer to a newly allocated wide character string, use + PyMem_RawFree() to free the memory. If size is not NULL, write the number of + wide characters excluding the null character into *size - Return a pointer to a newly allocated wide character string (use - PyMem_RawFree() to free the memory) and write the number of written wide - characters excluding the null character into *size if size is not NULL, or - NULL on error (decoding or memory allocation error). If size is not NULL, - *size is set to (size_t)-1 on memory error and (size_t)-2 on decoding - error. + Return NULL on decoding error or memory allocation error. If *size* is not + NULL, *size is set to (size_t)-1 on memory error or set to (size_t)-2 on + decoding error. + + Decoding errors should never happen, unless there is a bug in the C + library. - Conversion errors should never happen, unless there is a bug in the C - library. */ + Use the Py_EncodeLocale() function to encode the character string back to a + byte string. */ wchar_t* -_Py_char2wchar(const char* arg, size_t *size) +Py_DecodeLocale(const char* arg, size_t *size) { #ifdef __APPLE__ wchar_t *wstr; @@ -399,19 +408,20 @@ oom: #endif /* __APPLE__ */ } -/* Encode a (wide) character string to the locale encoding with the - surrogateescape error handler (characters in range U+DC80..U+DCFF are - converted to bytes 0x80..0xFF). +/* Encode a wide character string to the locale encoding with the + surrogateescape error handler: surrogate characters in the range + U+DC80..U+DCFF are converted to bytes 0x80..0xFF. - This function is the reverse of _Py_char2wchar(). + Return a pointer to a newly allocated byte string, use PyMem_Free() to free + the memory. Return NULL on encoding or memory allocation error. - Return a pointer to a newly allocated byte string (use PyMem_Free() to free - the memory), or NULL on encoding or memory allocation error. + If error_pos is not NULL, *error_pos is set to the index of the invalid + character on encoding error, or set to (size_t)-1 otherwise. - If error_pos is not NULL: *error_pos is the index of the invalid character - on encoding error, or (size_t)-1 otherwise. */ + Use the Py_DecodeLocale() function to decode the bytes string back to a wide + character string. */ char* -_Py_wchar2char(const wchar_t *text, size_t *error_pos) +Py_EncodeLocale(const wchar_t *text, size_t *error_pos) { #ifdef __APPLE__ Py_ssize_t len; @@ -514,34 +524,179 @@ _Py_wchar2char(const wchar_t *text, size_t *error_pos) #endif /* __APPLE__ */ } -/* In principle, this should use HAVE__WSTAT, and _wstat - should be detected by autoconf. However, no current - POSIX system provides that function, so testing for - it is pointless. - Not sure whether the MS_WINDOWS guards are necessary: - perhaps for cygwin/mingw builds? -*/ -#if defined(HAVE_STAT) && !defined(MS_WINDOWS) -/* Get file status. Encode the path to the locale encoding. */ +#ifdef MS_WINDOWS +static __int64 secs_between_epochs = 11644473600; /* Seconds between 1.1.1601 and 1.1.1970 */ + +static void +FILE_TIME_to_time_t_nsec(FILETIME *in_ptr, time_t *time_out, int* nsec_out) +{ + /* XXX endianness. Shouldn't matter, as all Windows implementations are little-endian */ + /* Cannot simply cast and dereference in_ptr, + since it might not be aligned properly */ + __int64 in; + memcpy(&in, in_ptr, sizeof(in)); + *nsec_out = (int)(in % 10000000) * 100; /* FILETIME is in units of 100 nsec. */ + *time_out = Py_SAFE_DOWNCAST((in / 10000000) - secs_between_epochs, __int64, time_t); +} + +void +_Py_time_t_to_FILE_TIME(time_t time_in, int nsec_in, FILETIME *out_ptr) +{ + /* XXX endianness */ + __int64 out; + out = time_in + secs_between_epochs; + out = out * 10000000 + nsec_in / 100; + memcpy(out_ptr, &out, sizeof(out)); +} +/* Below, we *know* that ugo+r is 0444 */ +#if _S_IREAD != 0400 +#error Unsupported C library +#endif +static int +attributes_to_mode(DWORD attr) +{ + int m = 0; + if (attr & FILE_ATTRIBUTE_DIRECTORY) + m |= _S_IFDIR | 0111; /* IFEXEC for user,group,other */ + else + m |= _S_IFREG; + if (attr & FILE_ATTRIBUTE_READONLY) + m |= 0444; + else + m |= 0666; + return m; +} + +void +_Py_attribute_data_to_stat(BY_HANDLE_FILE_INFORMATION *info, ULONG reparse_tag, + struct _Py_stat_struct *result) +{ + memset(result, 0, sizeof(*result)); + result->st_mode = attributes_to_mode(info->dwFileAttributes); + result->st_size = (((__int64)info->nFileSizeHigh)<<32) + info->nFileSizeLow; + result->st_dev = info->dwVolumeSerialNumber; + result->st_rdev = result->st_dev; + FILE_TIME_to_time_t_nsec(&info->ftCreationTime, &result->st_ctime, &result->st_ctime_nsec); + FILE_TIME_to_time_t_nsec(&info->ftLastWriteTime, &result->st_mtime, &result->st_mtime_nsec); + FILE_TIME_to_time_t_nsec(&info->ftLastAccessTime, &result->st_atime, &result->st_atime_nsec); + result->st_nlink = info->nNumberOfLinks; + result->st_ino = (((__int64)info->nFileIndexHigh)<<32) + info->nFileIndexLow; + if (reparse_tag == IO_REPARSE_TAG_SYMLINK) { + /* first clear the S_IFMT bits */ + result->st_mode ^= (result->st_mode & S_IFMT); + /* now set the bits that make this a symlink */ + result->st_mode |= S_IFLNK; + } + result->st_file_attributes = info->dwFileAttributes; +} +#endif + +/* Return information about a file. + + On POSIX, use fstat(). + + On Windows, use GetFileType() and GetFileInformationByHandle() which support + files larger than 2 GB. fstat() may fail with EOVERFLOW on files larger + than 2 GB because the file size type is an signed 32-bit integer: see issue + #23152. + + On Windows, set the last Windows error and return nonzero on error. On + POSIX, set errno and return nonzero on error. Fill status and return 0 on + success. */ int -_Py_wstat(const wchar_t* path, struct stat *buf) +_Py_fstat_noraise(int fd, struct _Py_stat_struct *status) { - int err; - char *fname; - fname = _Py_wchar2char(path, NULL); - if (fname == NULL) { - errno = EINVAL; +#ifdef MS_WINDOWS + BY_HANDLE_FILE_INFORMATION info; + HANDLE h; + int type; + + if (!_PyVerify_fd(fd)) + h = INVALID_HANDLE_VALUE; + else { + _Py_BEGIN_SUPPRESS_IPH + h = (HANDLE)_get_osfhandle(fd); + _Py_END_SUPPRESS_IPH + } + + if (h == INVALID_HANDLE_VALUE) { + /* errno is already set by _get_osfhandle, but we also set + the Win32 error for callers who expect that */ + SetLastError(ERROR_INVALID_HANDLE); return -1; } - err = stat(fname, buf); - PyMem_Free(fname); - return err; -} + memset(status, 0, sizeof(*status)); + + type = GetFileType(h); + if (type == FILE_TYPE_UNKNOWN) { + DWORD error = GetLastError(); + if (error != 0) { + errno = winerror_to_errno(error); + return -1; + } + /* else: valid but unknown file */ + } + + if (type != FILE_TYPE_DISK) { + if (type == FILE_TYPE_CHAR) + status->st_mode = _S_IFCHR; + else if (type == FILE_TYPE_PIPE) + status->st_mode = _S_IFIFO; + return 0; + } + + if (!GetFileInformationByHandle(h, &info)) { + /* The Win32 error is already set, but we also set errno for + callers who expect it */ + errno = winerror_to_errno(GetLastError()); + return -1; + } + + _Py_attribute_data_to_stat(&info, 0, status); + /* specific to fstat() */ + status->st_ino = (((__int64)info.nFileIndexHigh)<<32) + info.nFileIndexLow; + return 0; +#else + return fstat(fd, status); #endif +} + +/* Return information about a file. + + On POSIX, use fstat(). + + On Windows, use GetFileType() and GetFileInformationByHandle() which support + files larger than 2 GB. fstat() may fail with EOVERFLOW on files larger + than 2 GB because the file size type is an signed 32-bit integer: see issue + #23152. -#ifdef HAVE_STAT + Raise an exception and return -1 on error. On Windows, set the last Windows + error on error. On POSIX, set errno on error. Fill status and return 0 on + success. + + Release the GIL to call GetFileType() and GetFileInformationByHandle(), or + to call fstat(). The caller must hold the GIL. */ +int +_Py_fstat(int fd, struct _Py_stat_struct *status) +{ + int res; + + Py_BEGIN_ALLOW_THREADS + res = _Py_fstat_noraise(fd, status); + Py_END_ALLOW_THREADS + + if (res != 0) { +#ifdef MS_WINDOWS + PyErr_SetFromWindowsErr(0); +#else + PyErr_SetFromErrno(PyExc_OSError); +#endif + return -1; + } + return 0; +} /* Call _wstat() on Windows, or encode the path to the filesystem encoding and call stat() otherwise. Only fill st_mode attribute on Windows. @@ -575,7 +730,6 @@ _Py_stat(PyObject *path, struct stat *statbuf) #endif } -#endif static int get_inheritable(int fd, int raise) @@ -590,7 +744,9 @@ get_inheritable(int fd, int raise) return -1; } + _Py_BEGIN_SUPPRESS_IPH handle = (HANDLE)_get_osfhandle(fd); + _Py_END_SUPPRESS_IPH if (handle == INVALID_HANDLE_VALUE) { if (raise) PyErr_SetFromErrno(PyExc_OSError); @@ -665,7 +821,9 @@ set_inheritable(int fd, int inheritable, int raise, int *atomic_flag_works) return -1; } + _Py_BEGIN_SUPPRESS_IPH handle = (HANDLE)_get_osfhandle(fd); + _Py_END_SUPPRESS_IPH if (handle == INVALID_HANDLE_VALUE) { if (raise) PyErr_SetFromErrno(PyExc_OSError); @@ -767,40 +925,92 @@ _Py_set_inheritable(int fd, int inheritable, int *atomic_flag_works) return set_inheritable(fd, inheritable, 1, atomic_flag_works); } -/* Open a file with the specified flags (wrapper to open() function). - The file descriptor is created non-inheritable. */ -int -_Py_open(const char *pathname, int flags) +static int +_Py_open_impl(const char *pathname, int flags, int gil_held) { int fd; -#ifdef MS_WINDOWS - fd = open(pathname, flags | O_NOINHERIT); - if (fd < 0) - return fd; -#else - + int async_err = 0; +#ifndef MS_WINDOWS int *atomic_flag_works; -#ifdef O_CLOEXEC +#endif + +#ifdef MS_WINDOWS + flags |= O_NOINHERIT; +#elif defined(O_CLOEXEC) atomic_flag_works = &_Py_open_cloexec_works; flags |= O_CLOEXEC; #else atomic_flag_works = NULL; #endif - fd = open(pathname, flags); - if (fd < 0) - return fd; - if (set_inheritable(fd, 0, 0, atomic_flag_works) < 0) { + if (gil_held) { + do { + Py_BEGIN_ALLOW_THREADS + fd = open(pathname, flags); + Py_END_ALLOW_THREADS + } while (fd < 0 + && errno == EINTR && !(async_err = PyErr_CheckSignals())); + if (async_err) + return -1; + if (fd < 0) { + PyErr_SetFromErrnoWithFilename(PyExc_OSError, pathname); + return -1; + } + } + else { + fd = open(pathname, flags); + if (fd < 0) + return -1; + } + +#ifndef MS_WINDOWS + if (set_inheritable(fd, 0, gil_held, atomic_flag_works) < 0) { close(fd); return -1; } -#endif /* !MS_WINDOWS */ +#endif + return fd; } +/* Open a file with the specified flags (wrapper to open() function). + Return a file descriptor on success. Raise an exception and return -1 on + error. + + The file descriptor is created non-inheritable. + + When interrupted by a signal (open() fails with EINTR), retry the syscall, + except if the Python signal handler raises an exception. + + Release the GIL to call open(). The caller must hold the GIL. */ +int +_Py_open(const char *pathname, int flags) +{ +#ifdef WITH_THREAD + /* _Py_open() must be called with the GIL held. */ + assert(PyGILState_Check()); +#endif + return _Py_open_impl(pathname, flags, 1); +} + +/* Open a file with the specified flags (wrapper to open() function). + Return a file descriptor on success. Set errno and return -1 on error. + + The file descriptor is created non-inheritable. + + If interrupted by a signal, fail with EINTR. */ +int +_Py_open_noraise(const char *pathname, int flags) +{ + return _Py_open_impl(pathname, flags, 0); +} + /* Open a file. Use _wfopen() on Windows, encode the path to the locale - encoding and use fopen() otherwise. The file descriptor is created - non-inheritable. */ + encoding and use fopen() otherwise. + + The file descriptor is created non-inheritable. + + If interrupted by a signal, fail with EINTR. */ FILE * _Py_wfopen(const wchar_t *path, const wchar_t *mode) { @@ -814,7 +1024,7 @@ _Py_wfopen(const wchar_t *path, const wchar_t *mode) errno = EINVAL; return NULL; } - cpath = _Py_wchar2char(path, NULL); + cpath = Py_EncodeLocale(path, NULL); if (cpath == NULL) return NULL; f = fopen(cpath, cmode); @@ -831,7 +1041,11 @@ _Py_wfopen(const wchar_t *path, const wchar_t *mode) return f; } -/* Wrapper to fopen(). The file descriptor is created non-inheritable. */ +/* Wrapper to fopen(). + + The file descriptor is created non-inheritable. + + If interrupted by a signal, fail with EINTR. */ FILE* _Py_fopen(const char *pathname, const char *mode) { @@ -846,20 +1060,32 @@ _Py_fopen(const char *pathname, const char *mode) } /* Open a file. Call _wfopen() on Windows, or encode the path to the filesystem - encoding and call fopen() otherwise. The file descriptor is created - non-inheritable. + encoding and call fopen() otherwise. - Return the new file object on success, or NULL if the file cannot be open or - (if PyErr_Occurred()) on unicode error. */ + Return the new file object on success. Raise an exception and return NULL + on error. + + The file descriptor is created non-inheritable. + + When interrupted by a signal (open() fails with EINTR), retry the syscall, + except if the Python signal handler raises an exception. + + Release the GIL to call _wfopen() or fopen(). The caller must hold + the GIL. */ FILE* _Py_fopen_obj(PyObject *path, const char *mode) { FILE *f; + int async_err = 0; #ifdef MS_WINDOWS wchar_t *wpath; wchar_t wmode[10]; int usize; +#ifdef WITH_THREAD + assert(PyGILState_Check()); +#endif + if (!PyUnicode_Check(path)) { PyErr_Format(PyExc_TypeError, "str file path expected under Windows, got %R", @@ -871,26 +1097,249 @@ _Py_fopen_obj(PyObject *path, const char *mode) return NULL; usize = MultiByteToWideChar(CP_ACP, 0, mode, -1, wmode, sizeof(wmode)); - if (usize == 0) + if (usize == 0) { + PyErr_SetFromWindowsErr(0); return NULL; + } - f = _wfopen(wpath, wmode); + do { + Py_BEGIN_ALLOW_THREADS + f = _wfopen(wpath, wmode); + Py_END_ALLOW_THREADS + } while (f == NULL + && errno == EINTR && !(async_err = PyErr_CheckSignals())); #else PyObject *bytes; + char *path_bytes; + +#ifdef WITH_THREAD + assert(PyGILState_Check()); +#endif + if (!PyUnicode_FSConverter(path, &bytes)) return NULL; - f = fopen(PyBytes_AS_STRING(bytes), mode); + path_bytes = PyBytes_AS_STRING(bytes); + + do { + Py_BEGIN_ALLOW_THREADS + f = fopen(path_bytes, mode); + Py_END_ALLOW_THREADS + } while (f == NULL + && errno == EINTR && !(async_err = PyErr_CheckSignals())); + Py_DECREF(bytes); #endif - if (f == NULL) + if (async_err) return NULL; - if (make_non_inheritable(fileno(f)) < 0) { + + if (f == NULL) { + PyErr_SetFromErrnoWithFilenameObject(PyExc_OSError, path); + return NULL; + } + + if (set_inheritable(fileno(f), 0, 1, NULL) < 0) { fclose(f); return NULL; } return f; } +/* Read count bytes from fd into buf. + + On success, return the number of read bytes, it can be lower than count. + If the current file offset is at or past the end of file, no bytes are read, + and read() returns zero. + + On error, raise an exception, set errno and return -1. + + When interrupted by a signal (read() fails with EINTR), retry the syscall. + If the Python signal handler raises an exception, the function returns -1 + (the syscall is not retried). + + Release the GIL to call read(). The caller must hold the GIL. */ +Py_ssize_t +_Py_read(int fd, void *buf, size_t count) +{ + Py_ssize_t n; + int err; + int async_err = 0; + + /* _Py_read() must not be called with an exception set, otherwise the + * caller may think that read() was interrupted by a signal and the signal + * handler raised an exception. */ + assert(!PyErr_Occurred()); + + if (!_PyVerify_fd(fd)) { + /* save/restore errno because PyErr_SetFromErrno() can modify it */ + err = errno; + PyErr_SetFromErrno(PyExc_OSError); + errno = err; + return -1; + } + +#ifdef MS_WINDOWS + if (count > INT_MAX) { + /* On Windows, the count parameter of read() is an int */ + count = INT_MAX; + } +#else + if (count > PY_SSIZE_T_MAX) { + /* if count is greater than PY_SSIZE_T_MAX, + * read() result is undefined */ + count = PY_SSIZE_T_MAX; + } +#endif + + _Py_BEGIN_SUPPRESS_IPH + do { + Py_BEGIN_ALLOW_THREADS + errno = 0; +#ifdef MS_WINDOWS + n = read(fd, buf, (int)count); +#else + n = read(fd, buf, count); +#endif + /* save/restore errno because PyErr_CheckSignals() + * and PyErr_SetFromErrno() can modify it */ + err = errno; + Py_END_ALLOW_THREADS + } while (n < 0 && err == EINTR && + !(async_err = PyErr_CheckSignals())); + _Py_END_SUPPRESS_IPH + + if (async_err) { + /* read() was interrupted by a signal (failed with EINTR) + * and the Python signal handler raised an exception */ + errno = err; + assert(errno == EINTR && PyErr_Occurred()); + return -1; + } + if (n < 0) { + PyErr_SetFromErrno(PyExc_OSError); + errno = err; + return -1; + } + + return n; +} + +static Py_ssize_t +_Py_write_impl(int fd, const void *buf, size_t count, int gil_held) +{ + Py_ssize_t n; + int err; + int async_err = 0; + + if (!_PyVerify_fd(fd)) { + if (gil_held) { + /* save/restore errno because PyErr_SetFromErrno() can modify it */ + err = errno; + PyErr_SetFromErrno(PyExc_OSError); + errno = err; + } + return -1; + } + + _Py_BEGIN_SUPPRESS_IPH +#ifdef MS_WINDOWS + if (count > 32767 && isatty(fd)) { + /* Issue #11395: the Windows console returns an error (12: not + enough space error) on writing into stdout if stdout mode is + binary and the length is greater than 66,000 bytes (or less, + depending on heap usage). */ + count = 32767; + } + else if (count > INT_MAX) + count = INT_MAX; +#else + if (count > PY_SSIZE_T_MAX) { + /* write() should truncate count to PY_SSIZE_T_MAX, but it's safer + * to do it ourself to have a portable behaviour. */ + count = PY_SSIZE_T_MAX; + } +#endif + + if (gil_held) { + do { + Py_BEGIN_ALLOW_THREADS + errno = 0; +#ifdef MS_WINDOWS + n = write(fd, buf, (int)count); +#else + n = write(fd, buf, count); +#endif + /* save/restore errno because PyErr_CheckSignals() + * and PyErr_SetFromErrno() can modify it */ + err = errno; + Py_END_ALLOW_THREADS + } while (n < 0 && err == EINTR && + !(async_err = PyErr_CheckSignals())); + } + else { + do { + errno = 0; +#ifdef MS_WINDOWS + n = write(fd, buf, (int)count); +#else + n = write(fd, buf, count); +#endif + err = errno; + } while (n < 0 && err == EINTR); + } + _Py_END_SUPPRESS_IPH + + if (async_err) { + /* write() was interrupted by a signal (failed with EINTR) + and the Python signal handler raised an exception (if gil_held is + nonzero). */ + errno = err; + assert(errno == EINTR && (!gil_held || PyErr_Occurred())); + return -1; + } + if (n < 0) { + if (gil_held) + PyErr_SetFromErrno(PyExc_OSError); + errno = err; + return -1; + } + + return n; +} + +/* Write count bytes of buf into fd. + + On success, return the number of written bytes, it can be lower than count + including 0. On error, raise an exception, set errno and return -1. + + When interrupted by a signal (write() fails with EINTR), retry the syscall. + If the Python signal handler raises an exception, the function returns -1 + (the syscall is not retried). + + Release the GIL to call write(). The caller must hold the GIL. */ +Py_ssize_t +_Py_write(int fd, const void *buf, size_t count) +{ + /* _Py_write() must not be called with an exception set, otherwise the + * caller may think that write() was interrupted by a signal and the signal + * handler raised an exception. */ + assert(!PyErr_Occurred()); + + return _Py_write_impl(fd, buf, count, 1); +} + +/* Write count bytes of buf into fd. + * + * On success, return the number of written bytes, it can be lower than count + * including 0. On error, set errno and return -1. + * + * When interrupted by a signal (write() fails with EINTR), retry the syscall + * without calling the Python signal handler. */ +Py_ssize_t +_Py_write_noraise(int fd, const void *buf, size_t count) +{ + return _Py_write_impl(fd, buf, count, 0); +} + #ifdef HAVE_READLINK /* Read value of symbolic link. Encode the path to the locale encoding, decode @@ -905,7 +1354,7 @@ _Py_wreadlink(const wchar_t *path, wchar_t *buf, size_t bufsiz) int res; size_t r1; - cpath = _Py_wchar2char(path, NULL); + cpath = Py_EncodeLocale(path, NULL); if (cpath == NULL) { errno = EINVAL; return -1; @@ -919,7 +1368,7 @@ _Py_wreadlink(const wchar_t *path, wchar_t *buf, size_t bufsiz) return -1; } cbuf[res] = '\0'; /* buf will be null terminated */ - wbuf = _Py_char2wchar(cbuf, &r1); + wbuf = Py_DecodeLocale(cbuf, &r1); if (wbuf == NULL) { errno = EINVAL; return -1; @@ -950,7 +1399,7 @@ _Py_wrealpath(const wchar_t *path, wchar_t *wresolved_path; char *res; size_t r; - cpath = _Py_wchar2char(path, NULL); + cpath = Py_EncodeLocale(path, NULL); if (cpath == NULL) { errno = EINVAL; return NULL; @@ -960,7 +1409,7 @@ _Py_wrealpath(const wchar_t *path, if (res == NULL) return NULL; - wresolved_path = _Py_char2wchar(cresolved_path, &r); + wresolved_path = Py_DecodeLocale(cresolved_path, &r); if (wresolved_path == NULL) { errno = EINVAL; return NULL; @@ -993,7 +1442,7 @@ _Py_wgetcwd(wchar_t *buf, size_t size) if (getcwd(fname, Py_ARRAY_LENGTH(fname)) == NULL) return NULL; - wname = _Py_char2wchar(fname, &len); + wname = Py_DecodeLocale(fname, &len); if (wname == NULL) return NULL; if (size <= len) { @@ -1025,7 +1474,9 @@ _Py_dup(int fd) } #ifdef MS_WINDOWS + _Py_BEGIN_SUPPRESS_IPH handle = (HANDLE)_get_osfhandle(fd); + _Py_END_SUPPRESS_IPH if (handle == INVALID_HANDLE_VALUE) { PyErr_SetFromErrno(PyExc_OSError); return -1; @@ -1035,7 +1486,9 @@ _Py_dup(int fd) ftype = GetFileType(handle); Py_BEGIN_ALLOW_THREADS + _Py_BEGIN_SUPPRESS_IPH fd = dup(fd); + _Py_END_SUPPRESS_IPH Py_END_ALLOW_THREADS if (fd < 0) { PyErr_SetFromErrno(PyExc_OSError); @@ -1045,13 +1498,17 @@ _Py_dup(int fd) /* Character files like console cannot be make non-inheritable */ if (ftype != FILE_TYPE_CHAR) { if (_Py_set_inheritable(fd, 0, NULL) < 0) { + _Py_BEGIN_SUPPRESS_IPH close(fd); + _Py_END_SUPPRESS_IPH return -1; } } #elif defined(HAVE_FCNTL_H) && defined(F_DUPFD_CLOEXEC) Py_BEGIN_ALLOW_THREADS + _Py_BEGIN_SUPPRESS_IPH fd = fcntl(fd, F_DUPFD_CLOEXEC, 0); + _Py_END_SUPPRESS_IPH Py_END_ALLOW_THREADS if (fd < 0) { PyErr_SetFromErrno(PyExc_OSError); @@ -1060,7 +1517,9 @@ _Py_dup(int fd) #else Py_BEGIN_ALLOW_THREADS + _Py_BEGIN_SUPPRESS_IPH fd = dup(fd); + _Py_END_SUPPRESS_IPH Py_END_ALLOW_THREADS if (fd < 0) { PyErr_SetFromErrno(PyExc_OSError); @@ -1068,10 +1527,152 @@ _Py_dup(int fd) } if (_Py_set_inheritable(fd, 0, NULL) < 0) { + _Py_BEGIN_SUPPRESS_IPH close(fd); + _Py_END_SUPPRESS_IPH return -1; } #endif return fd; } +#ifndef MS_WINDOWS +/* Get the blocking mode of the file descriptor. + Return 0 if the O_NONBLOCK flag is set, 1 if the flag is cleared, + raise an exception and return -1 on error. */ +int +_Py_get_blocking(int fd) +{ + int flags; + _Py_BEGIN_SUPPRESS_IPH + flags = fcntl(fd, F_GETFL, 0); + _Py_END_SUPPRESS_IPH + if (flags < 0) { + PyErr_SetFromErrno(PyExc_OSError); + return -1; + } + + return !(flags & O_NONBLOCK); +} + +/* Set the blocking mode of the specified file descriptor. + + Set the O_NONBLOCK flag if blocking is False, clear the O_NONBLOCK flag + otherwise. + + Return 0 on success, raise an exception and return -1 on error. */ +int +_Py_set_blocking(int fd, int blocking) +{ +#if defined(HAVE_SYS_IOCTL_H) && defined(FIONBIO) + int arg = !blocking; + if (ioctl(fd, FIONBIO, &arg) < 0) + goto error; +#else + int flags, res; + + _Py_BEGIN_SUPPRESS_IPH + flags = fcntl(fd, F_GETFL, 0); + if (flags >= 0) { + if (blocking) + flags = flags & (~O_NONBLOCK); + else + flags = flags | O_NONBLOCK; + + res = fcntl(fd, F_SETFL, flags); + } else { + res = -1; + } + _Py_END_SUPPRESS_IPH + + if (res < 0) + goto error; +#endif + return 0; + +error: + PyErr_SetFromErrno(PyExc_OSError); + return -1; +} +#endif + +#if defined _MSC_VER && _MSC_VER >= 1400 && _MSC_VER < 1900 +/* Legacy implementation of _PyVerify_fd while transitioning to + * MSVC 14.0. This should eventually be removed. (issue23524) + */ + +/* Microsoft CRT in VS2005 and higher will verify that a filehandle is + * valid and raise an assertion if it isn't. + * Normally, an invalid fd is likely to be a C program error and therefore + * an assertion can be useful, but it does contradict the POSIX standard + * which for write(2) states: + * "Otherwise, -1 shall be returned and errno set to indicate the error." + * "[EBADF] The fildes argument is not a valid file descriptor open for + * writing." + * Furthermore, python allows the user to enter any old integer + * as a fd and should merely raise a python exception on error. + * The Microsoft CRT doesn't provide an official way to check for the + * validity of a file descriptor, but we can emulate its internal behaviour + * by using the exported __pinfo data member and knowledge of the + * internal structures involved. + * The structures below must be updated for each version of visual studio + * according to the file internal.h in the CRT source, until MS comes + * up with a less hacky way to do this. + * (all of this is to avoid globally modifying the CRT behaviour using + * _set_invalid_parameter_handler() and _CrtSetReportMode()) + */ +/* The actual size of the structure is determined at runtime. + * Only the first items must be present. + */ +typedef struct { + intptr_t osfhnd; + char osfile; +} my_ioinfo; + +extern __declspec(dllimport) char * __pioinfo[]; +#define IOINFO_L2E 5 +#define IOINFO_ARRAYS 64 +#define IOINFO_ARRAY_ELTS (1 << IOINFO_L2E) +#define _NHANDLE_ (IOINFO_ARRAYS * IOINFO_ARRAY_ELTS) +#define FOPEN 0x01 +#define _NO_CONSOLE_FILENO (intptr_t)-2 + +/* This function emulates what the windows CRT does to validate file handles */ +int +_PyVerify_fd(int fd) +{ + const int i1 = fd >> IOINFO_L2E; + const int i2 = fd & ((1 << IOINFO_L2E) - 1); + + static size_t sizeof_ioinfo = 0; + + /* Determine the actual size of the ioinfo structure, + * as used by the CRT loaded in memory + */ + if (sizeof_ioinfo == 0 && __pioinfo[0] != NULL) { + sizeof_ioinfo = _msize(__pioinfo[0]) / IOINFO_ARRAY_ELTS; + } + if (sizeof_ioinfo == 0) { + /* This should not happen... */ + goto fail; + } + + /* See that it isn't a special CLEAR fileno */ + if (fd != _NO_CONSOLE_FILENO) { + /* Microsoft CRT would check that 0<=fd<_nhandle but we can't do that. Instead + * we check pointer validity and other info + */ + if (0 <= i1 && i1 < IOINFO_ARRAYS && __pioinfo[i1] != NULL) { + /* finally, check that the file is open */ + my_ioinfo* info = (my_ioinfo*)(__pioinfo[i1] + i2 * sizeof_ioinfo); + if (info->osfile & FOPEN) { + return 1; + } + } + } + fail: + errno = EBADF; + return 0; +} + +#endif /* defined _MSC_VER && _MSC_VER >= 1400 && _MSC_VER < 1900 */ diff --git a/Python/formatter_unicode.c b/Python/formatter_unicode.c index e3a8149841..056bb76902 100644 --- a/Python/formatter_unicode.c +++ b/Python/formatter_unicode.c @@ -846,6 +846,13 @@ format_long_internal(PyObject *value, const InternalFormatSpec *format, " format specifier 'c'"); goto done; } + /* error to request alternate format */ + if (format->alternate) { + PyErr_SetString(PyExc_ValueError, + "Alternate form (#) not allowed with integer" + " format specifier 'c'"); + goto done; + } /* taken from unicodeobject.c formatchar() */ /* Integer input truncated to a character */ diff --git a/Python/frozen.c b/Python/frozen.c index 9bc662b994..676f395488 100644 --- a/Python/frozen.c +++ b/Python/frozen.c @@ -3,6 +3,7 @@ #include "Python.h" #include "importlib.h" +#include "importlib_external.h" /* In order to test the support for frozen modules, by default we define a single frozen module, __hello__. Loading it will print @@ -31,6 +32,8 @@ static unsigned char M___hello__[] = { static const struct _frozen _PyImport_FrozenModules[] = { /* importlib */ {"_frozen_importlib", _Py_M__importlib, (int)sizeof(_Py_M__importlib)}, + {"_frozen_importlib_external", _Py_M__importlib_external, + (int)sizeof(_Py_M__importlib_external)}, /* Test module */ {"__hello__", M___hello__, SIZE}, /* Test package (negative size indicates package-ness) */ diff --git a/Python/frozenmain.c b/Python/frozenmain.c index b05c94a7e1..de8bd35453 100644 --- a/Python/frozenmain.c +++ b/Python/frozenmain.c @@ -54,7 +54,7 @@ Py_FrozenMain(int argc, char **argv) setlocale(LC_ALL, ""); for (i = 0; i < argc; i++) { - argv_copy[i] = _Py_char2wchar(argv[i], NULL); + argv_copy[i] = Py_DecodeLocale(argv[i], NULL); argv_copy2[i] = argv_copy[i]; if (!argv_copy[i]) { fprintf(stderr, "Unable to decode the command line argument #%i\n", diff --git a/Python/future.c b/Python/future.c index 81eab54dd6..163f87f673 100644 --- a/Python/future.c +++ b/Python/future.c @@ -40,6 +40,8 @@ future_check_features(PyFutureFeatures *ff, stmt_ty s, PyObject *filename) continue; } else if (strcmp(feature, FUTURE_BARRY_AS_BDFL) == 0) { ff->ff_features |= CO_FUTURE_BARRY_AS_BDFL; + } else if (strcmp(feature, FUTURE_GENERATOR_STOP) == 0) { + ff->ff_features |= CO_FUTURE_GENERATOR_STOP; } else if (strcmp(feature, "braces") == 0) { PyErr_SetString(PyExc_SyntaxError, "not a chance"); diff --git a/Python/getargs.c b/Python/getargs.c index 6902d13489..c365fc25a3 100644 --- a/Python/getargs.c +++ b/Python/getargs.c @@ -872,10 +872,10 @@ convertsimple(PyObject *arg, const char **p_format, va_list *p_va, int flags, STORE_SIZE(count); format++; } else { - if (strlen(*p) != count) - return converterr( - "bytes without null bytes", - arg, msgbuf, bufsize); + if (strlen(*p) != (size_t)count) { + PyErr_SetString(PyExc_ValueError, "embedded null byte"); + RETURN_ERR_OCCURRED; + } } break; } @@ -948,16 +948,15 @@ convertsimple(PyObject *arg, const char **p_format, va_list *p_va, int flags, if (sarg == NULL) return converterr(CONV_UNICODE, arg, msgbuf, bufsize); + if (strlen(sarg) != (size_t)len) { + PyErr_SetString(PyExc_ValueError, "embedded null character"); + RETURN_ERR_OCCURRED; + } *p = sarg; } else return converterr(c == 'z' ? "str or None" : "str", arg, msgbuf, bufsize); - if (*p != NULL && sarg != NULL && (Py_ssize_t) strlen(*p) != len) - return converterr( - c == 'z' ? "str without null characters or None" - : "str without null characters", - arg, msgbuf, bufsize); } break; } @@ -995,10 +994,10 @@ convertsimple(PyObject *arg, const char **p_format, va_list *p_va, int flags, *p = PyUnicode_AsUnicodeAndSize(arg, &len); if (*p == NULL) RETURN_ERR_OCCURRED; - if (Py_UNICODE_strlen(*p) != len) - return converterr( - "str without null characters or None", - arg, msgbuf, bufsize); + if (Py_UNICODE_strlen(*p) != (size_t)len) { + PyErr_SetString(PyExc_ValueError, "embedded null character"); + RETURN_ERR_OCCURRED; + } } else return converterr(c == 'Z' ? "str or None" : "str", arg, msgbuf, bufsize); @@ -1246,7 +1245,8 @@ convertsimple(PyObject *arg, const char **p_format, va_list *p_va, int flags, supports it directly. */ if (PyObject_GetBuffer(arg, (Py_buffer*)p, PyBUF_WRITABLE) < 0) { PyErr_Clear(); - return converterr("read-write buffer", arg, msgbuf, bufsize); + return converterr("read-write bytes-like object", + arg, msgbuf, bufsize); } if (!PyBuffer_IsContiguous((Py_buffer*)p, 'C')) { PyBuffer_Release((Py_buffer*)p); @@ -1284,7 +1284,7 @@ convertbuffer(PyObject *arg, void **p, char **errmsg) *errmsg = NULL; *p = NULL; if (pb != NULL && pb->bf_releasebuffer != NULL) { - *errmsg = "read-only pinned buffer"; + *errmsg = "read-only bytes-like object"; return -1; } @@ -1300,7 +1300,7 @@ static int getbuffer(PyObject *arg, Py_buffer *view, char **errmsg) { if (PyObject_GetBuffer(arg, view, PyBUF_SIMPLE) != 0) { - *errmsg = "bytes or buffer"; + *errmsg = "bytes-like object"; return -1; } if (!PyBuffer_IsContiguous(view, 'C')) { diff --git a/Python/graminit.c b/Python/graminit.c index e04999bbff..8212b2a584 100644 --- a/Python/graminit.c +++ b/Python/graminit.c @@ -92,393 +92,406 @@ static state states_4[2] = { static arc arcs_5_0[1] = { {16, 1}, }; -static arc arcs_5_1[2] = { +static arc arcs_5_1[3] = { {18, 2}, {19, 2}, + {20, 2}, }; static arc arcs_5_2[1] = { {0, 2}, }; static state states_5[3] = { {1, arcs_5_0}, - {2, arcs_5_1}, + {3, arcs_5_1}, {1, arcs_5_2}, }; static arc arcs_6_0[1] = { - {20, 1}, + {21, 1}, }; static arc arcs_6_1[1] = { - {21, 2}, + {19, 2}, }; static arc arcs_6_2[1] = { - {22, 3}, + {0, 2}, }; -static arc arcs_6_3[2] = { - {23, 4}, - {25, 5}, +static state states_6[3] = { + {1, arcs_6_0}, + {1, arcs_6_1}, + {1, arcs_6_2}, }; -static arc arcs_6_4[1] = { - {24, 6}, +static arc arcs_7_0[1] = { + {22, 1}, }; -static arc arcs_6_5[1] = { - {26, 7}, +static arc arcs_7_1[1] = { + {23, 2}, }; -static arc arcs_6_6[1] = { - {25, 5}, +static arc arcs_7_2[1] = { + {24, 3}, }; -static arc arcs_6_7[1] = { +static arc arcs_7_3[2] = { + {25, 4}, + {27, 5}, +}; +static arc arcs_7_4[1] = { + {26, 6}, +}; +static arc arcs_7_5[1] = { + {28, 7}, +}; +static arc arcs_7_6[1] = { + {27, 5}, +}; +static arc arcs_7_7[1] = { {0, 7}, }; -static state states_6[8] = { - {1, arcs_6_0}, - {1, arcs_6_1}, - {1, arcs_6_2}, - {2, arcs_6_3}, - {1, arcs_6_4}, - {1, arcs_6_5}, - {1, arcs_6_6}, - {1, arcs_6_7}, +static state states_7[8] = { + {1, arcs_7_0}, + {1, arcs_7_1}, + {1, arcs_7_2}, + {2, arcs_7_3}, + {1, arcs_7_4}, + {1, arcs_7_5}, + {1, arcs_7_6}, + {1, arcs_7_7}, }; -static arc arcs_7_0[1] = { +static arc arcs_8_0[1] = { {13, 1}, }; -static arc arcs_7_1[2] = { - {27, 2}, +static arc arcs_8_1[2] = { + {29, 2}, {15, 3}, }; -static arc arcs_7_2[1] = { +static arc arcs_8_2[1] = { {15, 3}, }; -static arc arcs_7_3[1] = { +static arc arcs_8_3[1] = { {0, 3}, }; -static state states_7[4] = { - {1, arcs_7_0}, - {2, arcs_7_1}, - {1, arcs_7_2}, - {1, arcs_7_3}, +static state states_8[4] = { + {1, arcs_8_0}, + {2, arcs_8_1}, + {1, arcs_8_2}, + {1, arcs_8_3}, }; -static arc arcs_8_0[3] = { - {28, 1}, - {31, 2}, - {32, 3}, +static arc arcs_9_0[3] = { + {30, 1}, + {33, 2}, + {34, 3}, }; -static arc arcs_8_1[3] = { - {29, 4}, - {30, 5}, +static arc arcs_9_1[3] = { + {31, 4}, + {32, 5}, {0, 1}, }; -static arc arcs_8_2[3] = { - {28, 6}, - {30, 7}, +static arc arcs_9_2[3] = { + {30, 6}, + {32, 7}, {0, 2}, }; -static arc arcs_8_3[1] = { - {28, 8}, +static arc arcs_9_3[1] = { + {30, 8}, }; -static arc arcs_8_4[1] = { - {24, 9}, +static arc arcs_9_4[1] = { + {26, 9}, }; -static arc arcs_8_5[4] = { - {28, 10}, - {31, 11}, - {32, 3}, +static arc arcs_9_5[4] = { + {30, 10}, + {33, 11}, + {34, 3}, {0, 5}, }; -static arc arcs_8_6[2] = { - {30, 7}, +static arc arcs_9_6[2] = { + {32, 7}, {0, 6}, }; -static arc arcs_8_7[2] = { - {28, 12}, - {32, 3}, +static arc arcs_9_7[2] = { + {30, 12}, + {34, 3}, }; -static arc arcs_8_8[1] = { +static arc arcs_9_8[1] = { {0, 8}, }; -static arc arcs_8_9[2] = { - {30, 5}, +static arc arcs_9_9[2] = { + {32, 5}, {0, 9}, }; -static arc arcs_8_10[3] = { - {30, 5}, - {29, 4}, +static arc arcs_9_10[3] = { + {32, 5}, + {31, 4}, {0, 10}, }; -static arc arcs_8_11[3] = { - {28, 13}, - {30, 14}, +static arc arcs_9_11[3] = { + {30, 13}, + {32, 14}, {0, 11}, }; -static arc arcs_8_12[3] = { - {30, 7}, - {29, 15}, +static arc arcs_9_12[3] = { + {32, 7}, + {31, 15}, {0, 12}, }; -static arc arcs_8_13[2] = { - {30, 14}, +static arc arcs_9_13[2] = { + {32, 14}, {0, 13}, }; -static arc arcs_8_14[2] = { - {28, 16}, - {32, 3}, +static arc arcs_9_14[2] = { + {30, 16}, + {34, 3}, }; -static arc arcs_8_15[1] = { - {24, 6}, +static arc arcs_9_15[1] = { + {26, 6}, }; -static arc arcs_8_16[3] = { - {30, 14}, - {29, 17}, +static arc arcs_9_16[3] = { + {32, 14}, + {31, 17}, {0, 16}, }; -static arc arcs_8_17[1] = { - {24, 13}, -}; -static state states_8[18] = { - {3, arcs_8_0}, - {3, arcs_8_1}, - {3, arcs_8_2}, - {1, arcs_8_3}, - {1, arcs_8_4}, - {4, arcs_8_5}, - {2, arcs_8_6}, - {2, arcs_8_7}, - {1, arcs_8_8}, - {2, arcs_8_9}, - {3, arcs_8_10}, - {3, arcs_8_11}, - {3, arcs_8_12}, - {2, arcs_8_13}, - {2, arcs_8_14}, - {1, arcs_8_15}, - {3, arcs_8_16}, - {1, arcs_8_17}, -}; -static arc arcs_9_0[1] = { - {21, 1}, +static arc arcs_9_17[1] = { + {26, 13}, }; -static arc arcs_9_1[2] = { - {25, 2}, +static state states_9[18] = { + {3, arcs_9_0}, + {3, arcs_9_1}, + {3, arcs_9_2}, + {1, arcs_9_3}, + {1, arcs_9_4}, + {4, arcs_9_5}, + {2, arcs_9_6}, + {2, arcs_9_7}, + {1, arcs_9_8}, + {2, arcs_9_9}, + {3, arcs_9_10}, + {3, arcs_9_11}, + {3, arcs_9_12}, + {2, arcs_9_13}, + {2, arcs_9_14}, + {1, arcs_9_15}, + {3, arcs_9_16}, + {1, arcs_9_17}, +}; +static arc arcs_10_0[1] = { + {23, 1}, +}; +static arc arcs_10_1[2] = { + {27, 2}, {0, 1}, }; -static arc arcs_9_2[1] = { - {24, 3}, +static arc arcs_10_2[1] = { + {26, 3}, }; -static arc arcs_9_3[1] = { +static arc arcs_10_3[1] = { {0, 3}, }; -static state states_9[4] = { - {1, arcs_9_0}, - {2, arcs_9_1}, - {1, arcs_9_2}, - {1, arcs_9_3}, +static state states_10[4] = { + {1, arcs_10_0}, + {2, arcs_10_1}, + {1, arcs_10_2}, + {1, arcs_10_3}, }; -static arc arcs_10_0[3] = { - {34, 1}, - {31, 2}, - {32, 3}, +static arc arcs_11_0[3] = { + {36, 1}, + {33, 2}, + {34, 3}, }; -static arc arcs_10_1[3] = { - {29, 4}, - {30, 5}, +static arc arcs_11_1[3] = { + {31, 4}, + {32, 5}, {0, 1}, }; -static arc arcs_10_2[3] = { - {34, 6}, - {30, 7}, +static arc arcs_11_2[3] = { + {36, 6}, + {32, 7}, {0, 2}, }; -static arc arcs_10_3[1] = { - {34, 8}, +static arc arcs_11_3[1] = { + {36, 8}, }; -static arc arcs_10_4[1] = { - {24, 9}, +static arc arcs_11_4[1] = { + {26, 9}, }; -static arc arcs_10_5[4] = { - {34, 10}, - {31, 11}, - {32, 3}, +static arc arcs_11_5[4] = { + {36, 10}, + {33, 11}, + {34, 3}, {0, 5}, }; -static arc arcs_10_6[2] = { - {30, 7}, +static arc arcs_11_6[2] = { + {32, 7}, {0, 6}, }; -static arc arcs_10_7[2] = { - {34, 12}, - {32, 3}, +static arc arcs_11_7[2] = { + {36, 12}, + {34, 3}, }; -static arc arcs_10_8[1] = { +static arc arcs_11_8[1] = { {0, 8}, }; -static arc arcs_10_9[2] = { - {30, 5}, +static arc arcs_11_9[2] = { + {32, 5}, {0, 9}, }; -static arc arcs_10_10[3] = { - {30, 5}, - {29, 4}, +static arc arcs_11_10[3] = { + {32, 5}, + {31, 4}, {0, 10}, }; -static arc arcs_10_11[3] = { - {34, 13}, - {30, 14}, +static arc arcs_11_11[3] = { + {36, 13}, + {32, 14}, {0, 11}, }; -static arc arcs_10_12[3] = { - {30, 7}, - {29, 15}, +static arc arcs_11_12[3] = { + {32, 7}, + {31, 15}, {0, 12}, }; -static arc arcs_10_13[2] = { - {30, 14}, +static arc arcs_11_13[2] = { + {32, 14}, {0, 13}, }; -static arc arcs_10_14[2] = { - {34, 16}, - {32, 3}, +static arc arcs_11_14[2] = { + {36, 16}, + {34, 3}, }; -static arc arcs_10_15[1] = { - {24, 6}, +static arc arcs_11_15[1] = { + {26, 6}, }; -static arc arcs_10_16[3] = { - {30, 14}, - {29, 17}, +static arc arcs_11_16[3] = { + {32, 14}, + {31, 17}, {0, 16}, }; -static arc arcs_10_17[1] = { - {24, 13}, +static arc arcs_11_17[1] = { + {26, 13}, +}; +static state states_11[18] = { + {3, arcs_11_0}, + {3, arcs_11_1}, + {3, arcs_11_2}, + {1, arcs_11_3}, + {1, arcs_11_4}, + {4, arcs_11_5}, + {2, arcs_11_6}, + {2, arcs_11_7}, + {1, arcs_11_8}, + {2, arcs_11_9}, + {3, arcs_11_10}, + {3, arcs_11_11}, + {3, arcs_11_12}, + {2, arcs_11_13}, + {2, arcs_11_14}, + {1, arcs_11_15}, + {3, arcs_11_16}, + {1, arcs_11_17}, +}; +static arc arcs_12_0[1] = { + {23, 1}, }; -static state states_10[18] = { - {3, arcs_10_0}, - {3, arcs_10_1}, - {3, arcs_10_2}, - {1, arcs_10_3}, - {1, arcs_10_4}, - {4, arcs_10_5}, - {2, arcs_10_6}, - {2, arcs_10_7}, - {1, arcs_10_8}, - {2, arcs_10_9}, - {3, arcs_10_10}, - {3, arcs_10_11}, - {3, arcs_10_12}, - {2, arcs_10_13}, - {2, arcs_10_14}, - {1, arcs_10_15}, - {3, arcs_10_16}, - {1, arcs_10_17}, -}; -static arc arcs_11_0[1] = { - {21, 1}, -}; -static arc arcs_11_1[1] = { +static arc arcs_12_1[1] = { {0, 1}, }; -static state states_11[2] = { - {1, arcs_11_0}, - {1, arcs_11_1}, +static state states_12[2] = { + {1, arcs_12_0}, + {1, arcs_12_1}, }; -static arc arcs_12_0[2] = { +static arc arcs_13_0[2] = { {3, 1}, {4, 1}, }; -static arc arcs_12_1[1] = { +static arc arcs_13_1[1] = { {0, 1}, }; -static state states_12[2] = { - {2, arcs_12_0}, - {1, arcs_12_1}, +static state states_13[2] = { + {2, arcs_13_0}, + {1, arcs_13_1}, }; -static arc arcs_13_0[1] = { - {35, 1}, +static arc arcs_14_0[1] = { + {37, 1}, }; -static arc arcs_13_1[2] = { - {36, 2}, +static arc arcs_14_1[2] = { + {38, 2}, {2, 3}, }; -static arc arcs_13_2[2] = { - {35, 1}, +static arc arcs_14_2[2] = { + {37, 1}, {2, 3}, }; -static arc arcs_13_3[1] = { +static arc arcs_14_3[1] = { {0, 3}, }; -static state states_13[4] = { - {1, arcs_13_0}, - {2, arcs_13_1}, - {2, arcs_13_2}, - {1, arcs_13_3}, +static state states_14[4] = { + {1, arcs_14_0}, + {2, arcs_14_1}, + {2, arcs_14_2}, + {1, arcs_14_3}, }; -static arc arcs_14_0[8] = { - {37, 1}, - {38, 1}, +static arc arcs_15_0[8] = { {39, 1}, {40, 1}, {41, 1}, {42, 1}, {43, 1}, {44, 1}, + {45, 1}, + {46, 1}, }; -static arc arcs_14_1[1] = { +static arc arcs_15_1[1] = { {0, 1}, }; -static state states_14[2] = { - {8, arcs_14_0}, - {1, arcs_14_1}, +static state states_15[2] = { + {8, arcs_15_0}, + {1, arcs_15_1}, }; -static arc arcs_15_0[1] = { - {45, 1}, +static arc arcs_16_0[1] = { + {47, 1}, }; -static arc arcs_15_1[3] = { - {46, 2}, - {29, 3}, +static arc arcs_16_1[3] = { + {48, 2}, + {31, 3}, {0, 1}, }; -static arc arcs_15_2[2] = { - {47, 4}, +static arc arcs_16_2[2] = { + {49, 4}, {9, 4}, }; -static arc arcs_15_3[2] = { +static arc arcs_16_3[2] = { + {49, 5}, {47, 5}, - {45, 5}, }; -static arc arcs_15_4[1] = { +static arc arcs_16_4[1] = { {0, 4}, }; -static arc arcs_15_5[2] = { - {29, 3}, +static arc arcs_16_5[2] = { + {31, 3}, {0, 5}, }; -static state states_15[6] = { - {1, arcs_15_0}, - {3, arcs_15_1}, - {2, arcs_15_2}, - {2, arcs_15_3}, - {1, arcs_15_4}, - {2, arcs_15_5}, +static state states_16[6] = { + {1, arcs_16_0}, + {3, arcs_16_1}, + {2, arcs_16_2}, + {2, arcs_16_3}, + {1, arcs_16_4}, + {2, arcs_16_5}, }; -static arc arcs_16_0[2] = { - {24, 1}, - {48, 1}, +static arc arcs_17_0[2] = { + {26, 1}, + {50, 1}, }; -static arc arcs_16_1[2] = { - {30, 2}, +static arc arcs_17_1[2] = { + {32, 2}, {0, 1}, }; -static arc arcs_16_2[3] = { - {24, 1}, - {48, 1}, +static arc arcs_17_2[3] = { + {26, 1}, + {50, 1}, {0, 2}, }; -static state states_16[3] = { - {2, arcs_16_0}, - {2, arcs_16_1}, - {3, arcs_16_2}, +static state states_17[3] = { + {2, arcs_17_0}, + {2, arcs_17_1}, + {3, arcs_17_2}, }; -static arc arcs_17_0[12] = { - {49, 1}, - {50, 1}, +static arc arcs_18_0[13] = { {51, 1}, {52, 1}, {53, 1}, @@ -489,64 +502,57 @@ static arc arcs_17_0[12] = { {58, 1}, {59, 1}, {60, 1}, -}; -static arc arcs_17_1[1] = { - {0, 1}, -}; -static state states_17[2] = { - {12, arcs_17_0}, - {1, arcs_17_1}, -}; -static arc arcs_18_0[1] = { {61, 1}, + {62, 1}, + {63, 1}, }; static arc arcs_18_1[1] = { - {62, 2}, -}; -static arc arcs_18_2[1] = { - {0, 2}, + {0, 1}, }; -static state states_18[3] = { - {1, arcs_18_0}, +static state states_18[2] = { + {13, arcs_18_0}, {1, arcs_18_1}, - {1, arcs_18_2}, }; static arc arcs_19_0[1] = { - {63, 1}, + {64, 1}, }; static arc arcs_19_1[1] = { - {0, 1}, + {65, 2}, }; -static state states_19[2] = { +static arc arcs_19_2[1] = { + {0, 2}, +}; +static state states_19[3] = { {1, arcs_19_0}, {1, arcs_19_1}, + {1, arcs_19_2}, }; -static arc arcs_20_0[5] = { - {64, 1}, - {65, 1}, +static arc arcs_20_0[1] = { {66, 1}, - {67, 1}, - {68, 1}, }; static arc arcs_20_1[1] = { {0, 1}, }; static state states_20[2] = { - {5, arcs_20_0}, + {1, arcs_20_0}, {1, arcs_20_1}, }; -static arc arcs_21_0[1] = { +static arc arcs_21_0[5] = { + {67, 1}, + {68, 1}, {69, 1}, + {70, 1}, + {71, 1}, }; static arc arcs_21_1[1] = { {0, 1}, }; static state states_21[2] = { - {1, arcs_21_0}, + {5, arcs_21_0}, {1, arcs_21_1}, }; static arc arcs_22_0[1] = { - {70, 1}, + {72, 1}, }; static arc arcs_22_1[1] = { {0, 1}, @@ -556,148 +562,139 @@ static state states_22[2] = { {1, arcs_22_1}, }; static arc arcs_23_0[1] = { - {71, 1}, + {73, 1}, }; -static arc arcs_23_1[2] = { - {9, 2}, +static arc arcs_23_1[1] = { {0, 1}, }; -static arc arcs_23_2[1] = { - {0, 2}, -}; -static state states_23[3] = { +static state states_23[2] = { {1, arcs_23_0}, - {2, arcs_23_1}, - {1, arcs_23_2}, + {1, arcs_23_1}, }; static arc arcs_24_0[1] = { - {47, 1}, + {74, 1}, }; -static arc arcs_24_1[1] = { +static arc arcs_24_1[2] = { + {9, 2}, {0, 1}, }; -static state states_24[2] = { +static arc arcs_24_2[1] = { + {0, 2}, +}; +static state states_24[3] = { {1, arcs_24_0}, - {1, arcs_24_1}, + {2, arcs_24_1}, + {1, arcs_24_2}, }; static arc arcs_25_0[1] = { - {72, 1}, + {49, 1}, +}; +static arc arcs_25_1[1] = { + {0, 1}, +}; +static state states_25[2] = { + {1, arcs_25_0}, + {1, arcs_25_1}, }; -static arc arcs_25_1[2] = { - {24, 2}, +static arc arcs_26_0[1] = { + {75, 1}, +}; +static arc arcs_26_1[2] = { + {26, 2}, {0, 1}, }; -static arc arcs_25_2[2] = { - {73, 3}, +static arc arcs_26_2[2] = { + {76, 3}, {0, 2}, }; -static arc arcs_25_3[1] = { - {24, 4}, +static arc arcs_26_3[1] = { + {26, 4}, }; -static arc arcs_25_4[1] = { +static arc arcs_26_4[1] = { {0, 4}, }; -static state states_25[5] = { - {1, arcs_25_0}, - {2, arcs_25_1}, - {2, arcs_25_2}, - {1, arcs_25_3}, - {1, arcs_25_4}, +static state states_26[5] = { + {1, arcs_26_0}, + {2, arcs_26_1}, + {2, arcs_26_2}, + {1, arcs_26_3}, + {1, arcs_26_4}, }; -static arc arcs_26_0[2] = { - {74, 1}, - {75, 1}, +static arc arcs_27_0[2] = { + {77, 1}, + {78, 1}, }; -static arc arcs_26_1[1] = { +static arc arcs_27_1[1] = { {0, 1}, }; -static state states_26[2] = { - {2, arcs_26_0}, - {1, arcs_26_1}, +static state states_27[2] = { + {2, arcs_27_0}, + {1, arcs_27_1}, }; -static arc arcs_27_0[1] = { - {76, 1}, +static arc arcs_28_0[1] = { + {79, 1}, }; -static arc arcs_27_1[1] = { - {77, 2}, +static arc arcs_28_1[1] = { + {80, 2}, }; -static arc arcs_27_2[1] = { +static arc arcs_28_2[1] = { {0, 2}, }; -static state states_27[3] = { - {1, arcs_27_0}, - {1, arcs_27_1}, - {1, arcs_27_2}, +static state states_28[3] = { + {1, arcs_28_0}, + {1, arcs_28_1}, + {1, arcs_28_2}, }; -static arc arcs_28_0[1] = { - {73, 1}, +static arc arcs_29_0[1] = { + {76, 1}, }; -static arc arcs_28_1[3] = { - {78, 2}, - {79, 2}, +static arc arcs_29_1[3] = { + {81, 2}, + {82, 2}, {12, 3}, }; -static arc arcs_28_2[4] = { - {78, 2}, - {79, 2}, +static arc arcs_29_2[4] = { + {81, 2}, + {82, 2}, {12, 3}, - {76, 4}, + {79, 4}, }; -static arc arcs_28_3[1] = { - {76, 4}, +static arc arcs_29_3[1] = { + {79, 4}, }; -static arc arcs_28_4[3] = { - {31, 5}, +static arc arcs_29_4[3] = { + {33, 5}, {13, 6}, - {80, 5}, + {83, 5}, }; -static arc arcs_28_5[1] = { +static arc arcs_29_5[1] = { {0, 5}, }; -static arc arcs_28_6[1] = { - {80, 7}, +static arc arcs_29_6[1] = { + {83, 7}, }; -static arc arcs_28_7[1] = { +static arc arcs_29_7[1] = { {15, 5}, }; -static state states_28[8] = { - {1, arcs_28_0}, - {3, arcs_28_1}, - {4, arcs_28_2}, - {1, arcs_28_3}, - {3, arcs_28_4}, - {1, arcs_28_5}, - {1, arcs_28_6}, - {1, arcs_28_7}, -}; -static arc arcs_29_0[1] = { - {21, 1}, -}; -static arc arcs_29_1[2] = { - {82, 2}, - {0, 1}, -}; -static arc arcs_29_2[1] = { - {21, 3}, -}; -static arc arcs_29_3[1] = { - {0, 3}, -}; -static state states_29[4] = { +static state states_29[8] = { {1, arcs_29_0}, - {2, arcs_29_1}, - {1, arcs_29_2}, + {3, arcs_29_1}, + {4, arcs_29_2}, {1, arcs_29_3}, + {3, arcs_29_4}, + {1, arcs_29_5}, + {1, arcs_29_6}, + {1, arcs_29_7}, }; static arc arcs_30_0[1] = { - {12, 1}, + {23, 1}, }; static arc arcs_30_1[2] = { - {82, 2}, + {85, 2}, {0, 1}, }; static arc arcs_30_2[1] = { - {21, 3}, + {23, 3}, }; static arc arcs_30_3[1] = { {0, 3}, @@ -709,37 +706,45 @@ static state states_30[4] = { {1, arcs_30_3}, }; static arc arcs_31_0[1] = { - {81, 1}, + {12, 1}, }; static arc arcs_31_1[2] = { - {30, 2}, + {85, 2}, {0, 1}, }; -static arc arcs_31_2[2] = { - {81, 1}, - {0, 2}, +static arc arcs_31_2[1] = { + {23, 3}, }; -static state states_31[3] = { +static arc arcs_31_3[1] = { + {0, 3}, +}; +static state states_31[4] = { {1, arcs_31_0}, {2, arcs_31_1}, - {2, arcs_31_2}, + {1, arcs_31_2}, + {1, arcs_31_3}, }; static arc arcs_32_0[1] = { - {83, 1}, + {84, 1}, }; static arc arcs_32_1[2] = { - {30, 0}, + {32, 2}, {0, 1}, }; -static state states_32[2] = { +static arc arcs_32_2[2] = { + {84, 1}, + {0, 2}, +}; +static state states_32[3] = { {1, arcs_32_0}, {2, arcs_32_1}, + {2, arcs_32_2}, }; static arc arcs_33_0[1] = { - {21, 1}, + {86, 1}, }; static arc arcs_33_1[2] = { - {78, 0}, + {32, 0}, {0, 1}, }; static state states_33[2] = { @@ -747,28 +752,24 @@ static state states_33[2] = { {2, arcs_33_1}, }; static arc arcs_34_0[1] = { - {84, 1}, -}; -static arc arcs_34_1[1] = { - {21, 2}, + {23, 1}, }; -static arc arcs_34_2[2] = { - {30, 1}, - {0, 2}, +static arc arcs_34_1[2] = { + {81, 0}, + {0, 1}, }; -static state states_34[3] = { +static state states_34[2] = { {1, arcs_34_0}, - {1, arcs_34_1}, - {2, arcs_34_2}, + {2, arcs_34_1}, }; static arc arcs_35_0[1] = { - {85, 1}, + {87, 1}, }; static arc arcs_35_1[1] = { - {21, 2}, + {23, 2}, }; static arc arcs_35_2[2] = { - {30, 1}, + {32, 1}, {0, 2}, }; static state states_35[3] = { @@ -777,504 +778,514 @@ static state states_35[3] = { {2, arcs_35_2}, }; static arc arcs_36_0[1] = { - {86, 1}, + {88, 1}, }; static arc arcs_36_1[1] = { - {24, 2}, + {23, 2}, }; static arc arcs_36_2[2] = { - {30, 3}, + {32, 1}, {0, 2}, }; -static arc arcs_36_3[1] = { - {24, 4}, -}; -static arc arcs_36_4[1] = { - {0, 4}, -}; -static state states_36[5] = { +static state states_36[3] = { {1, arcs_36_0}, {1, arcs_36_1}, {2, arcs_36_2}, - {1, arcs_36_3}, - {1, arcs_36_4}, }; -static arc arcs_37_0[8] = { - {87, 1}, - {88, 1}, +static arc arcs_37_0[1] = { {89, 1}, - {90, 1}, - {91, 1}, - {19, 1}, - {18, 1}, - {17, 1}, }; static arc arcs_37_1[1] = { - {0, 1}, -}; -static state states_37[2] = { - {8, arcs_37_0}, - {1, arcs_37_1}, -}; -static arc arcs_38_0[1] = { - {92, 1}, + {26, 2}, }; -static arc arcs_38_1[1] = { - {24, 2}, -}; -static arc arcs_38_2[1] = { - {25, 3}, +static arc arcs_37_2[2] = { + {32, 3}, + {0, 2}, }; -static arc arcs_38_3[1] = { +static arc arcs_37_3[1] = { {26, 4}, }; -static arc arcs_38_4[3] = { - {93, 1}, - {94, 5}, +static arc arcs_37_4[1] = { {0, 4}, }; -static arc arcs_38_5[1] = { - {25, 6}, +static state states_37[5] = { + {1, arcs_37_0}, + {1, arcs_37_1}, + {2, arcs_37_2}, + {1, arcs_37_3}, + {1, arcs_37_4}, }; -static arc arcs_38_6[1] = { - {26, 7}, +static arc arcs_38_0[9] = { + {90, 1}, + {91, 1}, + {92, 1}, + {93, 1}, + {94, 1}, + {19, 1}, + {18, 1}, + {17, 1}, + {95, 1}, }; -static arc arcs_38_7[1] = { - {0, 7}, +static arc arcs_38_1[1] = { + {0, 1}, }; -static state states_38[8] = { - {1, arcs_38_0}, +static state states_38[2] = { + {9, arcs_38_0}, {1, arcs_38_1}, - {1, arcs_38_2}, - {1, arcs_38_3}, - {3, arcs_38_4}, - {1, arcs_38_5}, - {1, arcs_38_6}, - {1, arcs_38_7}, }; static arc arcs_39_0[1] = { - {95, 1}, + {21, 1}, }; -static arc arcs_39_1[1] = { - {24, 2}, +static arc arcs_39_1[3] = { + {19, 2}, + {94, 2}, + {92, 2}, }; static arc arcs_39_2[1] = { - {25, 3}, -}; -static arc arcs_39_3[1] = { - {26, 4}, -}; -static arc arcs_39_4[2] = { - {94, 5}, - {0, 4}, -}; -static arc arcs_39_5[1] = { - {25, 6}, -}; -static arc arcs_39_6[1] = { - {26, 7}, -}; -static arc arcs_39_7[1] = { - {0, 7}, + {0, 2}, }; -static state states_39[8] = { +static state states_39[3] = { {1, arcs_39_0}, - {1, arcs_39_1}, + {3, arcs_39_1}, {1, arcs_39_2}, - {1, arcs_39_3}, - {2, arcs_39_4}, - {1, arcs_39_5}, - {1, arcs_39_6}, - {1, arcs_39_7}, }; static arc arcs_40_0[1] = { {96, 1}, }; static arc arcs_40_1[1] = { - {62, 2}, + {26, 2}, }; static arc arcs_40_2[1] = { - {97, 3}, + {27, 3}, }; static arc arcs_40_3[1] = { - {9, 4}, + {28, 4}, }; -static arc arcs_40_4[1] = { - {25, 5}, +static arc arcs_40_4[3] = { + {97, 1}, + {98, 5}, + {0, 4}, }; static arc arcs_40_5[1] = { - {26, 6}, + {27, 6}, }; -static arc arcs_40_6[2] = { - {94, 7}, - {0, 6}, +static arc arcs_40_6[1] = { + {28, 7}, }; static arc arcs_40_7[1] = { - {25, 8}, -}; -static arc arcs_40_8[1] = { - {26, 9}, -}; -static arc arcs_40_9[1] = { - {0, 9}, + {0, 7}, }; -static state states_40[10] = { +static state states_40[8] = { {1, arcs_40_0}, {1, arcs_40_1}, {1, arcs_40_2}, {1, arcs_40_3}, - {1, arcs_40_4}, + {3, arcs_40_4}, {1, arcs_40_5}, - {2, arcs_40_6}, + {1, arcs_40_6}, {1, arcs_40_7}, - {1, arcs_40_8}, - {1, arcs_40_9}, }; static arc arcs_41_0[1] = { - {98, 1}, + {99, 1}, }; static arc arcs_41_1[1] = { - {25, 2}, + {26, 2}, }; static arc arcs_41_2[1] = { - {26, 3}, + {27, 3}, }; -static arc arcs_41_3[2] = { - {99, 4}, - {100, 5}, +static arc arcs_41_3[1] = { + {28, 4}, }; -static arc arcs_41_4[1] = { - {25, 6}, +static arc arcs_41_4[2] = { + {98, 5}, + {0, 4}, }; static arc arcs_41_5[1] = { - {25, 7}, + {27, 6}, }; static arc arcs_41_6[1] = { - {26, 8}, + {28, 7}, }; static arc arcs_41_7[1] = { - {26, 9}, -}; -static arc arcs_41_8[4] = { - {99, 4}, - {94, 10}, - {100, 5}, - {0, 8}, -}; -static arc arcs_41_9[1] = { - {0, 9}, -}; -static arc arcs_41_10[1] = { - {25, 11}, -}; -static arc arcs_41_11[1] = { - {26, 12}, -}; -static arc arcs_41_12[2] = { - {100, 5}, - {0, 12}, + {0, 7}, }; -static state states_41[13] = { +static state states_41[8] = { {1, arcs_41_0}, {1, arcs_41_1}, {1, arcs_41_2}, - {2, arcs_41_3}, - {1, arcs_41_4}, + {1, arcs_41_3}, + {2, arcs_41_4}, {1, arcs_41_5}, {1, arcs_41_6}, {1, arcs_41_7}, - {4, arcs_41_8}, - {1, arcs_41_9}, - {1, arcs_41_10}, - {1, arcs_41_11}, - {2, arcs_41_12}, }; static arc arcs_42_0[1] = { - {101, 1}, + {100, 1}, }; static arc arcs_42_1[1] = { - {102, 2}, + {65, 2}, }; -static arc arcs_42_2[2] = { - {30, 1}, - {25, 3}, +static arc arcs_42_2[1] = { + {101, 3}, }; static arc arcs_42_3[1] = { - {26, 4}, + {9, 4}, }; static arc arcs_42_4[1] = { - {0, 4}, + {27, 5}, +}; +static arc arcs_42_5[1] = { + {28, 6}, +}; +static arc arcs_42_6[2] = { + {98, 7}, + {0, 6}, +}; +static arc arcs_42_7[1] = { + {27, 8}, +}; +static arc arcs_42_8[1] = { + {28, 9}, +}; +static arc arcs_42_9[1] = { + {0, 9}, }; -static state states_42[5] = { +static state states_42[10] = { {1, arcs_42_0}, {1, arcs_42_1}, - {2, arcs_42_2}, + {1, arcs_42_2}, {1, arcs_42_3}, {1, arcs_42_4}, + {1, arcs_42_5}, + {2, arcs_42_6}, + {1, arcs_42_7}, + {1, arcs_42_8}, + {1, arcs_42_9}, }; static arc arcs_43_0[1] = { - {24, 1}, + {102, 1}, }; -static arc arcs_43_1[2] = { - {82, 2}, - {0, 1}, +static arc arcs_43_1[1] = { + {27, 2}, }; static arc arcs_43_2[1] = { - {103, 3}, + {28, 3}, }; -static arc arcs_43_3[1] = { - {0, 3}, +static arc arcs_43_3[2] = { + {103, 4}, + {104, 5}, +}; +static arc arcs_43_4[1] = { + {27, 6}, +}; +static arc arcs_43_5[1] = { + {27, 7}, +}; +static arc arcs_43_6[1] = { + {28, 8}, +}; +static arc arcs_43_7[1] = { + {28, 9}, +}; +static arc arcs_43_8[4] = { + {103, 4}, + {98, 10}, + {104, 5}, + {0, 8}, +}; +static arc arcs_43_9[1] = { + {0, 9}, +}; +static arc arcs_43_10[1] = { + {27, 11}, +}; +static arc arcs_43_11[1] = { + {28, 12}, }; -static state states_43[4] = { +static arc arcs_43_12[2] = { + {104, 5}, + {0, 12}, +}; +static state states_43[13] = { {1, arcs_43_0}, - {2, arcs_43_1}, + {1, arcs_43_1}, {1, arcs_43_2}, - {1, arcs_43_3}, + {2, arcs_43_3}, + {1, arcs_43_4}, + {1, arcs_43_5}, + {1, arcs_43_6}, + {1, arcs_43_7}, + {4, arcs_43_8}, + {1, arcs_43_9}, + {1, arcs_43_10}, + {1, arcs_43_11}, + {2, arcs_43_12}, }; static arc arcs_44_0[1] = { - {104, 1}, + {105, 1}, }; -static arc arcs_44_1[2] = { - {24, 2}, - {0, 1}, +static arc arcs_44_1[1] = { + {106, 2}, }; static arc arcs_44_2[2] = { - {82, 3}, - {0, 2}, + {32, 1}, + {27, 3}, }; static arc arcs_44_3[1] = { - {21, 4}, + {28, 4}, }; static arc arcs_44_4[1] = { {0, 4}, }; static state states_44[5] = { {1, arcs_44_0}, - {2, arcs_44_1}, + {1, arcs_44_1}, {2, arcs_44_2}, {1, arcs_44_3}, {1, arcs_44_4}, }; -static arc arcs_45_0[2] = { - {3, 1}, - {2, 2}, +static arc arcs_45_0[1] = { + {26, 1}, }; -static arc arcs_45_1[1] = { +static arc arcs_45_1[2] = { + {85, 2}, {0, 1}, }; static arc arcs_45_2[1] = { - {105, 3}, + {107, 3}, }; static arc arcs_45_3[1] = { - {6, 4}, -}; -static arc arcs_45_4[2] = { - {6, 4}, - {106, 1}, + {0, 3}, }; -static state states_45[5] = { - {2, arcs_45_0}, - {1, arcs_45_1}, +static state states_45[4] = { + {1, arcs_45_0}, + {2, arcs_45_1}, {1, arcs_45_2}, {1, arcs_45_3}, - {2, arcs_45_4}, }; -static arc arcs_46_0[2] = { - {107, 1}, - {108, 2}, +static arc arcs_46_0[1] = { + {108, 1}, }; static arc arcs_46_1[2] = { - {92, 3}, + {26, 2}, {0, 1}, }; -static arc arcs_46_2[1] = { +static arc arcs_46_2[2] = { + {85, 3}, {0, 2}, }; static arc arcs_46_3[1] = { - {107, 4}, + {23, 4}, }; static arc arcs_46_4[1] = { - {94, 5}, -}; -static arc arcs_46_5[1] = { - {24, 2}, + {0, 4}, }; -static state states_46[6] = { - {2, arcs_46_0}, +static state states_46[5] = { + {1, arcs_46_0}, {2, arcs_46_1}, - {1, arcs_46_2}, + {2, arcs_46_2}, {1, arcs_46_3}, {1, arcs_46_4}, - {1, arcs_46_5}, }; static arc arcs_47_0[2] = { - {107, 1}, - {110, 1}, + {3, 1}, + {2, 2}, }; static arc arcs_47_1[1] = { {0, 1}, }; -static state states_47[2] = { +static arc arcs_47_2[1] = { + {109, 3}, +}; +static arc arcs_47_3[1] = { + {6, 4}, +}; +static arc arcs_47_4[2] = { + {6, 4}, + {110, 1}, +}; +static state states_47[5] = { {2, arcs_47_0}, {1, arcs_47_1}, + {1, arcs_47_2}, + {1, arcs_47_3}, + {2, arcs_47_4}, }; -static arc arcs_48_0[1] = { +static arc arcs_48_0[2] = { {111, 1}, + {112, 2}, }; static arc arcs_48_1[2] = { - {33, 2}, - {25, 3}, + {96, 3}, + {0, 1}, }; static arc arcs_48_2[1] = { - {25, 3}, + {0, 2}, }; static arc arcs_48_3[1] = { - {24, 4}, + {111, 4}, }; static arc arcs_48_4[1] = { - {0, 4}, + {98, 5}, +}; +static arc arcs_48_5[1] = { + {26, 2}, }; -static state states_48[5] = { - {1, arcs_48_0}, +static state states_48[6] = { + {2, arcs_48_0}, {2, arcs_48_1}, {1, arcs_48_2}, {1, arcs_48_3}, {1, arcs_48_4}, + {1, arcs_48_5}, }; -static arc arcs_49_0[1] = { +static arc arcs_49_0[2] = { {111, 1}, + {114, 1}, }; -static arc arcs_49_1[2] = { - {33, 2}, - {25, 3}, +static arc arcs_49_1[1] = { + {0, 1}, }; -static arc arcs_49_2[1] = { - {25, 3}, +static state states_49[2] = { + {2, arcs_49_0}, + {1, arcs_49_1}, }; -static arc arcs_49_3[1] = { - {109, 4}, +static arc arcs_50_0[1] = { + {115, 1}, }; -static arc arcs_49_4[1] = { - {0, 4}, +static arc arcs_50_1[2] = { + {35, 2}, + {27, 3}, }; -static state states_49[5] = { - {1, arcs_49_0}, - {2, arcs_49_1}, - {1, arcs_49_2}, - {1, arcs_49_3}, - {1, arcs_49_4}, +static arc arcs_50_2[1] = { + {27, 3}, }; -static arc arcs_50_0[1] = { - {112, 1}, +static arc arcs_50_3[1] = { + {26, 4}, }; -static arc arcs_50_1[2] = { - {113, 0}, - {0, 1}, +static arc arcs_50_4[1] = { + {0, 4}, }; -static state states_50[2] = { +static state states_50[5] = { {1, arcs_50_0}, {2, arcs_50_1}, + {1, arcs_50_2}, + {1, arcs_50_3}, + {1, arcs_50_4}, }; static arc arcs_51_0[1] = { - {114, 1}, + {115, 1}, }; static arc arcs_51_1[2] = { - {115, 0}, - {0, 1}, + {35, 2}, + {27, 3}, +}; +static arc arcs_51_2[1] = { + {27, 3}, +}; +static arc arcs_51_3[1] = { + {113, 4}, +}; +static arc arcs_51_4[1] = { + {0, 4}, }; -static state states_51[2] = { +static state states_51[5] = { {1, arcs_51_0}, {2, arcs_51_1}, + {1, arcs_51_2}, + {1, arcs_51_3}, + {1, arcs_51_4}, }; -static arc arcs_52_0[2] = { +static arc arcs_52_0[1] = { {116, 1}, - {117, 2}, }; -static arc arcs_52_1[1] = { - {114, 2}, -}; -static arc arcs_52_2[1] = { - {0, 2}, +static arc arcs_52_1[2] = { + {117, 0}, + {0, 1}, }; -static state states_52[3] = { - {2, arcs_52_0}, - {1, arcs_52_1}, - {1, arcs_52_2}, +static state states_52[2] = { + {1, arcs_52_0}, + {2, arcs_52_1}, }; static arc arcs_53_0[1] = { - {103, 1}, + {118, 1}, }; static arc arcs_53_1[2] = { - {118, 0}, + {119, 0}, {0, 1}, }; static state states_53[2] = { {1, arcs_53_0}, {2, arcs_53_1}, }; -static arc arcs_54_0[10] = { - {119, 1}, +static arc arcs_54_0[2] = { {120, 1}, - {121, 1}, - {122, 1}, - {123, 1}, - {124, 1}, - {125, 1}, - {97, 1}, - {116, 2}, - {126, 3}, + {121, 2}, }; static arc arcs_54_1[1] = { - {0, 1}, + {118, 2}, }; static arc arcs_54_2[1] = { - {97, 1}, -}; -static arc arcs_54_3[2] = { - {116, 1}, - {0, 3}, + {0, 2}, }; -static state states_54[4] = { - {10, arcs_54_0}, +static state states_54[3] = { + {2, arcs_54_0}, {1, arcs_54_1}, {1, arcs_54_2}, - {2, arcs_54_3}, }; static arc arcs_55_0[1] = { - {31, 1}, -}; -static arc arcs_55_1[1] = { - {103, 2}, + {107, 1}, }; -static arc arcs_55_2[1] = { - {0, 2}, +static arc arcs_55_1[2] = { + {122, 0}, + {0, 1}, }; -static state states_55[3] = { +static state states_55[2] = { {1, arcs_55_0}, - {1, arcs_55_1}, - {1, arcs_55_2}, + {2, arcs_55_1}, }; -static arc arcs_56_0[1] = { +static arc arcs_56_0[10] = { + {123, 1}, + {124, 1}, + {125, 1}, + {126, 1}, {127, 1}, + {128, 1}, + {129, 1}, + {101, 1}, + {120, 2}, + {130, 3}, }; -static arc arcs_56_1[2] = { - {128, 0}, +static arc arcs_56_1[1] = { {0, 1}, }; -static state states_56[2] = { - {1, arcs_56_0}, - {2, arcs_56_1}, +static arc arcs_56_2[1] = { + {101, 1}, +}; +static arc arcs_56_3[2] = { + {120, 1}, + {0, 3}, +}; +static state states_56[4] = { + {10, arcs_56_0}, + {1, arcs_56_1}, + {1, arcs_56_2}, + {2, arcs_56_3}, }; static arc arcs_57_0[1] = { - {129, 1}, + {33, 1}, }; -static arc arcs_57_1[2] = { - {130, 0}, - {0, 1}, +static arc arcs_57_1[1] = { + {107, 2}, +}; +static arc arcs_57_2[1] = { + {0, 2}, }; -static state states_57[2] = { +static state states_57[3] = { {1, arcs_57_0}, - {2, arcs_57_1}, + {1, arcs_57_1}, + {1, arcs_57_2}, }; static arc arcs_58_0[1] = { {131, 1}, @@ -1290,752 +1301,793 @@ static state states_58[2] = { static arc arcs_59_0[1] = { {133, 1}, }; -static arc arcs_59_1[3] = { +static arc arcs_59_1[2] = { {134, 0}, - {135, 0}, {0, 1}, }; static state states_59[2] = { {1, arcs_59_0}, - {3, arcs_59_1}, + {2, arcs_59_1}, }; static arc arcs_60_0[1] = { - {136, 1}, + {135, 1}, }; -static arc arcs_60_1[3] = { - {137, 0}, - {138, 0}, +static arc arcs_60_1[2] = { + {136, 0}, {0, 1}, }; static state states_60[2] = { {1, arcs_60_0}, - {3, arcs_60_1}, + {2, arcs_60_1}, }; static arc arcs_61_0[1] = { - {139, 1}, + {137, 1}, }; -static arc arcs_61_1[5] = { - {31, 0}, - {140, 0}, - {141, 0}, - {142, 0}, +static arc arcs_61_1[3] = { + {138, 0}, + {139, 0}, {0, 1}, }; static state states_61[2] = { {1, arcs_61_0}, - {5, arcs_61_1}, + {3, arcs_61_1}, }; -static arc arcs_62_0[4] = { - {137, 1}, - {138, 1}, +static arc arcs_62_0[1] = { + {140, 1}, +}; +static arc arcs_62_1[3] = { + {141, 0}, + {142, 0}, + {0, 1}, +}; +static state states_62[2] = { + {1, arcs_62_0}, + {3, arcs_62_1}, +}; +static arc arcs_63_0[1] = { {143, 1}, - {144, 2}, }; -static arc arcs_62_1[1] = { - {139, 2}, +static arc arcs_63_1[6] = { + {33, 0}, + {11, 0}, + {144, 0}, + {145, 0}, + {146, 0}, + {0, 1}, +}; +static state states_63[2] = { + {1, arcs_63_0}, + {6, arcs_63_1}, +}; +static arc arcs_64_0[4] = { + {141, 1}, + {142, 1}, + {147, 1}, + {148, 2}, +}; +static arc arcs_64_1[1] = { + {143, 2}, }; -static arc arcs_62_2[1] = { +static arc arcs_64_2[1] = { {0, 2}, }; -static state states_62[3] = { - {4, arcs_62_0}, - {1, arcs_62_1}, - {1, arcs_62_2}, +static state states_64[3] = { + {4, arcs_64_0}, + {1, arcs_64_1}, + {1, arcs_64_2}, }; -static arc arcs_63_0[1] = { - {145, 1}, +static arc arcs_65_0[1] = { + {149, 1}, }; -static arc arcs_63_1[3] = { - {146, 1}, - {32, 2}, +static arc arcs_65_1[2] = { + {34, 2}, {0, 1}, }; -static arc arcs_63_2[1] = { - {139, 3}, +static arc arcs_65_2[1] = { + {143, 3}, }; -static arc arcs_63_3[1] = { +static arc arcs_65_3[1] = { {0, 3}, }; -static state states_63[4] = { - {1, arcs_63_0}, - {3, arcs_63_1}, - {1, arcs_63_2}, - {1, arcs_63_3}, +static state states_65[4] = { + {1, arcs_65_0}, + {2, arcs_65_1}, + {1, arcs_65_2}, + {1, arcs_65_3}, +}; +static arc arcs_66_0[2] = { + {150, 1}, + {151, 2}, +}; +static arc arcs_66_1[1] = { + {151, 2}, +}; +static arc arcs_66_2[2] = { + {152, 2}, + {0, 2}, +}; +static state states_66[3] = { + {2, arcs_66_0}, + {1, arcs_66_1}, + {2, arcs_66_2}, }; -static arc arcs_64_0[10] = { +static arc arcs_67_0[10] = { {13, 1}, - {148, 2}, - {150, 3}, - {21, 4}, - {153, 4}, - {154, 5}, - {79, 4}, - {155, 4}, - {156, 4}, - {157, 4}, + {154, 2}, + {156, 3}, + {23, 4}, + {159, 4}, + {160, 5}, + {82, 4}, + {161, 4}, + {162, 4}, + {163, 4}, }; -static arc arcs_64_1[3] = { - {47, 6}, - {147, 6}, +static arc arcs_67_1[3] = { + {49, 6}, + {153, 6}, {15, 4}, }; -static arc arcs_64_2[2] = { - {147, 7}, - {149, 4}, +static arc arcs_67_2[2] = { + {153, 7}, + {155, 4}, }; -static arc arcs_64_3[2] = { - {151, 8}, - {152, 4}, +static arc arcs_67_3[2] = { + {157, 8}, + {158, 4}, }; -static arc arcs_64_4[1] = { +static arc arcs_67_4[1] = { {0, 4}, }; -static arc arcs_64_5[2] = { - {154, 5}, +static arc arcs_67_5[2] = { + {160, 5}, {0, 5}, }; -static arc arcs_64_6[1] = { +static arc arcs_67_6[1] = { {15, 4}, }; -static arc arcs_64_7[1] = { - {149, 4}, -}; -static arc arcs_64_8[1] = { - {152, 4}, -}; -static state states_64[9] = { - {10, arcs_64_0}, - {3, arcs_64_1}, - {2, arcs_64_2}, - {2, arcs_64_3}, - {1, arcs_64_4}, - {2, arcs_64_5}, - {1, arcs_64_6}, - {1, arcs_64_7}, - {1, arcs_64_8}, -}; -static arc arcs_65_0[2] = { - {24, 1}, - {48, 1}, -}; -static arc arcs_65_1[3] = { - {158, 2}, - {30, 3}, +static arc arcs_67_7[1] = { + {155, 4}, +}; +static arc arcs_67_8[1] = { + {158, 4}, +}; +static state states_67[9] = { + {10, arcs_67_0}, + {3, arcs_67_1}, + {2, arcs_67_2}, + {2, arcs_67_3}, + {1, arcs_67_4}, + {2, arcs_67_5}, + {1, arcs_67_6}, + {1, arcs_67_7}, + {1, arcs_67_8}, +}; +static arc arcs_68_0[2] = { + {26, 1}, + {50, 1}, +}; +static arc arcs_68_1[3] = { + {164, 2}, + {32, 3}, {0, 1}, }; -static arc arcs_65_2[1] = { +static arc arcs_68_2[1] = { {0, 2}, }; -static arc arcs_65_3[3] = { - {24, 4}, - {48, 4}, +static arc arcs_68_3[3] = { + {26, 4}, + {50, 4}, {0, 3}, }; -static arc arcs_65_4[2] = { - {30, 3}, +static arc arcs_68_4[2] = { + {32, 3}, {0, 4}, }; -static state states_65[5] = { - {2, arcs_65_0}, - {3, arcs_65_1}, - {1, arcs_65_2}, - {3, arcs_65_3}, - {2, arcs_65_4}, +static state states_68[5] = { + {2, arcs_68_0}, + {3, arcs_68_1}, + {1, arcs_68_2}, + {3, arcs_68_3}, + {2, arcs_68_4}, }; -static arc arcs_66_0[3] = { +static arc arcs_69_0[3] = { {13, 1}, - {148, 2}, - {78, 3}, + {154, 2}, + {81, 3}, }; -static arc arcs_66_1[2] = { +static arc arcs_69_1[2] = { {14, 4}, {15, 5}, }; -static arc arcs_66_2[1] = { - {159, 6}, +static arc arcs_69_2[1] = { + {165, 6}, }; -static arc arcs_66_3[1] = { - {21, 5}, +static arc arcs_69_3[1] = { + {23, 5}, }; -static arc arcs_66_4[1] = { +static arc arcs_69_4[1] = { {15, 5}, }; -static arc arcs_66_5[1] = { +static arc arcs_69_5[1] = { {0, 5}, }; -static arc arcs_66_6[1] = { - {149, 5}, +static arc arcs_69_6[1] = { + {155, 5}, }; -static state states_66[7] = { - {3, arcs_66_0}, - {2, arcs_66_1}, - {1, arcs_66_2}, - {1, arcs_66_3}, - {1, arcs_66_4}, - {1, arcs_66_5}, - {1, arcs_66_6}, +static state states_69[7] = { + {3, arcs_69_0}, + {2, arcs_69_1}, + {1, arcs_69_2}, + {1, arcs_69_3}, + {1, arcs_69_4}, + {1, arcs_69_5}, + {1, arcs_69_6}, }; -static arc arcs_67_0[1] = { - {160, 1}, +static arc arcs_70_0[1] = { + {166, 1}, }; -static arc arcs_67_1[2] = { - {30, 2}, +static arc arcs_70_1[2] = { + {32, 2}, {0, 1}, }; -static arc arcs_67_2[2] = { - {160, 1}, +static arc arcs_70_2[2] = { + {166, 1}, {0, 2}, }; -static state states_67[3] = { - {1, arcs_67_0}, - {2, arcs_67_1}, - {2, arcs_67_2}, +static state states_70[3] = { + {1, arcs_70_0}, + {2, arcs_70_1}, + {2, arcs_70_2}, }; -static arc arcs_68_0[2] = { - {24, 1}, - {25, 2}, +static arc arcs_71_0[2] = { + {26, 1}, + {27, 2}, }; -static arc arcs_68_1[2] = { - {25, 2}, +static arc arcs_71_1[2] = { + {27, 2}, {0, 1}, }; -static arc arcs_68_2[3] = { - {24, 3}, - {161, 4}, +static arc arcs_71_2[3] = { + {26, 3}, + {167, 4}, {0, 2}, }; -static arc arcs_68_3[2] = { - {161, 4}, +static arc arcs_71_3[2] = { + {167, 4}, {0, 3}, }; -static arc arcs_68_4[1] = { +static arc arcs_71_4[1] = { {0, 4}, }; -static state states_68[5] = { - {2, arcs_68_0}, - {2, arcs_68_1}, - {3, arcs_68_2}, - {2, arcs_68_3}, - {1, arcs_68_4}, +static state states_71[5] = { + {2, arcs_71_0}, + {2, arcs_71_1}, + {3, arcs_71_2}, + {2, arcs_71_3}, + {1, arcs_71_4}, }; -static arc arcs_69_0[1] = { - {25, 1}, +static arc arcs_72_0[1] = { + {27, 1}, }; -static arc arcs_69_1[2] = { - {24, 2}, +static arc arcs_72_1[2] = { + {26, 2}, {0, 1}, }; -static arc arcs_69_2[1] = { +static arc arcs_72_2[1] = { {0, 2}, }; -static state states_69[3] = { - {1, arcs_69_0}, - {2, arcs_69_1}, - {1, arcs_69_2}, +static state states_72[3] = { + {1, arcs_72_0}, + {2, arcs_72_1}, + {1, arcs_72_2}, }; -static arc arcs_70_0[2] = { - {103, 1}, - {48, 1}, +static arc arcs_73_0[2] = { + {107, 1}, + {50, 1}, }; -static arc arcs_70_1[2] = { - {30, 2}, +static arc arcs_73_1[2] = { + {32, 2}, {0, 1}, }; -static arc arcs_70_2[3] = { - {103, 1}, - {48, 1}, +static arc arcs_73_2[3] = { + {107, 1}, + {50, 1}, {0, 2}, }; -static state states_70[3] = { - {2, arcs_70_0}, - {2, arcs_70_1}, - {3, arcs_70_2}, +static state states_73[3] = { + {2, arcs_73_0}, + {2, arcs_73_1}, + {3, arcs_73_2}, }; -static arc arcs_71_0[1] = { - {24, 1}, +static arc arcs_74_0[1] = { + {26, 1}, }; -static arc arcs_71_1[2] = { - {30, 2}, +static arc arcs_74_1[2] = { + {32, 2}, {0, 1}, }; -static arc arcs_71_2[2] = { - {24, 1}, +static arc arcs_74_2[2] = { + {26, 1}, {0, 2}, }; -static state states_71[3] = { - {1, arcs_71_0}, - {2, arcs_71_1}, - {2, arcs_71_2}, +static state states_74[3] = { + {1, arcs_74_0}, + {2, arcs_74_1}, + {2, arcs_74_2}, }; -static arc arcs_72_0[1] = { - {24, 1}, +static arc arcs_75_0[3] = { + {26, 1}, + {34, 2}, + {50, 3}, }; -static arc arcs_72_1[4] = { - {25, 2}, - {158, 3}, - {30, 4}, +static arc arcs_75_1[4] = { + {27, 4}, + {164, 5}, + {32, 6}, {0, 1}, }; -static arc arcs_72_2[1] = { - {24, 5}, +static arc arcs_75_2[1] = { + {107, 7}, }; -static arc arcs_72_3[1] = { +static arc arcs_75_3[3] = { + {164, 5}, + {32, 6}, {0, 3}, }; -static arc arcs_72_4[2] = { - {24, 6}, - {0, 4}, +static arc arcs_75_4[1] = { + {26, 7}, }; -static arc arcs_72_5[3] = { - {158, 3}, - {30, 7}, +static arc arcs_75_5[1] = { {0, 5}, }; -static arc arcs_72_6[2] = { - {30, 4}, +static arc arcs_75_6[3] = { + {26, 8}, + {50, 8}, {0, 6}, }; -static arc arcs_72_7[2] = { - {24, 8}, +static arc arcs_75_7[3] = { + {164, 5}, + {32, 9}, {0, 7}, }; -static arc arcs_72_8[1] = { - {25, 9}, +static arc arcs_75_8[2] = { + {32, 6}, + {0, 8}, }; -static arc arcs_72_9[1] = { - {24, 10}, +static arc arcs_75_9[3] = { + {26, 10}, + {34, 11}, + {0, 9}, }; -static arc arcs_72_10[2] = { - {30, 7}, - {0, 10}, +static arc arcs_75_10[1] = { + {27, 12}, }; -static state states_72[11] = { - {1, 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}, -}; -static arc arcs_73_0[1] = { - {162, 1}, -}; -static arc arcs_73_1[1] = { - {21, 2}, -}; -static arc arcs_73_2[2] = { +static arc arcs_75_11[1] = { + {107, 13}, +}; +static arc arcs_75_12[1] = { + {26, 13}, +}; +static arc arcs_75_13[2] = { + {32, 9}, + {0, 13}, +}; +static state states_75[14] = { + {3, arcs_75_0}, + {4, arcs_75_1}, + {1, arcs_75_2}, + {3, arcs_75_3}, + {1, arcs_75_4}, + {1, arcs_75_5}, + {3, arcs_75_6}, + {3, arcs_75_7}, + {2, arcs_75_8}, + {3, arcs_75_9}, + {1, arcs_75_10}, + {1, arcs_75_11}, + {1, arcs_75_12}, + {2, arcs_75_13}, +}; +static arc arcs_76_0[1] = { + {168, 1}, +}; +static arc arcs_76_1[1] = { + {23, 2}, +}; +static arc arcs_76_2[2] = { {13, 3}, - {25, 4}, + {27, 4}, }; -static arc arcs_73_3[2] = { +static arc arcs_76_3[2] = { {14, 5}, {15, 6}, }; -static arc arcs_73_4[1] = { - {26, 7}, +static arc arcs_76_4[1] = { + {28, 7}, }; -static arc arcs_73_5[1] = { +static arc arcs_76_5[1] = { {15, 6}, }; -static arc arcs_73_6[1] = { - {25, 4}, +static arc arcs_76_6[1] = { + {27, 4}, }; -static arc arcs_73_7[1] = { +static arc arcs_76_7[1] = { {0, 7}, }; -static state states_73[8] = { - {1, arcs_73_0}, - {1, arcs_73_1}, - {2, arcs_73_2}, - {2, arcs_73_3}, - {1, arcs_73_4}, - {1, arcs_73_5}, - {1, arcs_73_6}, - {1, arcs_73_7}, -}; -static arc arcs_74_0[3] = { - {163, 1}, - {31, 2}, - {32, 3}, -}; -static arc arcs_74_1[2] = { - {30, 4}, - {0, 1}, -}; -static arc arcs_74_2[1] = { - {24, 5}, +static state states_76[8] = { + {1, arcs_76_0}, + {1, arcs_76_1}, + {2, arcs_76_2}, + {2, arcs_76_3}, + {1, arcs_76_4}, + {1, arcs_76_5}, + {1, arcs_76_6}, + {1, arcs_76_7}, }; -static arc arcs_74_3[1] = { - {24, 6}, +static arc arcs_77_0[1] = { + {169, 1}, }; -static arc arcs_74_4[4] = { - {163, 1}, - {31, 2}, - {32, 3}, - {0, 4}, +static arc arcs_77_1[2] = { + {32, 2}, + {0, 1}, }; -static arc arcs_74_5[2] = { - {30, 7}, - {0, 5}, +static arc arcs_77_2[2] = { + {169, 1}, + {0, 2}, }; -static arc arcs_74_6[1] = { - {0, 6}, +static state states_77[3] = { + {1, arcs_77_0}, + {2, arcs_77_1}, + {2, arcs_77_2}, }; -static arc arcs_74_7[2] = { - {163, 5}, - {32, 3}, +static arc arcs_78_0[3] = { + {26, 1}, + {34, 2}, + {33, 2}, }; -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] = { - {24, 1}, -}; -static arc arcs_75_1[3] = { - {158, 2}, - {29, 3}, +static arc arcs_78_1[3] = { + {164, 3}, + {31, 2}, {0, 1}, }; -static arc arcs_75_2[1] = { - {0, 2}, +static arc arcs_78_2[1] = { + {26, 3}, }; -static arc arcs_75_3[1] = { - {24, 2}, +static arc arcs_78_3[1] = { + {0, 3}, }; -static state states_75[4] = { - {1, arcs_75_0}, - {3, arcs_75_1}, - {1, arcs_75_2}, - {1, arcs_75_3}, +static state states_78[4] = { + {3, arcs_78_0}, + {3, arcs_78_1}, + {1, arcs_78_2}, + {1, arcs_78_3}, }; -static arc arcs_76_0[2] = { - {158, 1}, - {165, 1}, +static arc arcs_79_0[2] = { + {164, 1}, + {171, 1}, }; -static arc arcs_76_1[1] = { +static arc arcs_79_1[1] = { {0, 1}, }; -static state states_76[2] = { - {2, arcs_76_0}, - {1, arcs_76_1}, +static state states_79[2] = { + {2, arcs_79_0}, + {1, arcs_79_1}, }; -static arc arcs_77_0[1] = { - {96, 1}, +static arc arcs_80_0[1] = { + {100, 1}, }; -static arc arcs_77_1[1] = { - {62, 2}, +static arc arcs_80_1[1] = { + {65, 2}, }; -static arc arcs_77_2[1] = { - {97, 3}, +static arc arcs_80_2[1] = { + {101, 3}, }; -static arc arcs_77_3[1] = { - {107, 4}, +static arc arcs_80_3[1] = { + {111, 4}, }; -static arc arcs_77_4[2] = { - {164, 5}, +static arc arcs_80_4[2] = { + {170, 5}, {0, 4}, }; -static arc arcs_77_5[1] = { +static arc arcs_80_5[1] = { {0, 5}, }; -static state states_77[6] = { - {1, arcs_77_0}, - {1, arcs_77_1}, - {1, arcs_77_2}, - {1, arcs_77_3}, - {2, arcs_77_4}, - {1, arcs_77_5}, +static state states_80[6] = { + {1, arcs_80_0}, + {1, arcs_80_1}, + {1, arcs_80_2}, + {1, arcs_80_3}, + {2, arcs_80_4}, + {1, arcs_80_5}, }; -static arc arcs_78_0[1] = { - {92, 1}, +static arc arcs_81_0[1] = { + {96, 1}, }; -static arc arcs_78_1[1] = { - {109, 2}, +static arc arcs_81_1[1] = { + {113, 2}, }; -static arc arcs_78_2[2] = { - {164, 3}, +static arc arcs_81_2[2] = { + {170, 3}, {0, 2}, }; -static arc arcs_78_3[1] = { +static arc arcs_81_3[1] = { {0, 3}, }; -static state states_78[4] = { - {1, arcs_78_0}, - {1, arcs_78_1}, - {2, arcs_78_2}, - {1, arcs_78_3}, +static state states_81[4] = { + {1, arcs_81_0}, + {1, arcs_81_1}, + {2, arcs_81_2}, + {1, arcs_81_3}, }; -static arc arcs_79_0[1] = { - {21, 1}, +static arc arcs_82_0[1] = { + {23, 1}, }; -static arc arcs_79_1[1] = { +static arc arcs_82_1[1] = { {0, 1}, }; -static state states_79[2] = { - {1, arcs_79_0}, - {1, arcs_79_1}, +static state states_82[2] = { + {1, arcs_82_0}, + {1, arcs_82_1}, }; -static arc arcs_80_0[1] = { - {167, 1}, +static arc arcs_83_0[1] = { + {173, 1}, }; -static arc arcs_80_1[2] = { - {168, 2}, +static arc arcs_83_1[2] = { + {174, 2}, {0, 1}, }; -static arc arcs_80_2[1] = { +static arc arcs_83_2[1] = { {0, 2}, }; -static state states_80[3] = { - {1, arcs_80_0}, - {2, arcs_80_1}, - {1, arcs_80_2}, +static state states_83[3] = { + {1, arcs_83_0}, + {2, arcs_83_1}, + {1, arcs_83_2}, }; -static arc arcs_81_0[2] = { - {73, 1}, +static arc arcs_84_0[2] = { + {76, 1}, {9, 2}, }; -static arc arcs_81_1[1] = { - {24, 2}, +static arc arcs_84_1[1] = { + {26, 2}, }; -static arc arcs_81_2[1] = { +static arc arcs_84_2[1] = { {0, 2}, }; -static state states_81[3] = { - {2, arcs_81_0}, - {1, arcs_81_1}, - {1, arcs_81_2}, +static state states_84[3] = { + {2, arcs_84_0}, + {1, arcs_84_1}, + {1, arcs_84_2}, }; -static dfa dfas[82] = { +static dfa dfas[85] = { {256, "single_input", 0, 3, states_0, - "\004\050\060\200\000\000\000\240\340\223\160\220\045\200\020\000\000\206\120\076\204\000"}, + "\004\050\340\000\002\000\000\000\005\237\204\003\131\002\010\001\000\140\110\224\017\041"}, {257, "file_input", 0, 2, states_1, - "\204\050\060\200\000\000\000\240\340\223\160\220\045\200\020\000\000\206\120\076\204\000"}, + "\204\050\340\000\002\000\000\000\005\237\204\003\131\002\010\001\000\140\110\224\017\041"}, {258, "eval_input", 0, 3, states_2, - "\000\040\040\000\000\000\000\000\000\200\000\000\000\200\020\000\000\206\120\076\000\000"}, + "\000\040\200\000\000\000\000\000\000\000\004\000\000\000\010\001\000\140\110\224\017\000"}, {259, "decorator", 0, 7, states_3, "\000\010\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {260, "decorators", 0, 2, states_4, "\000\010\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {261, "decorated", 0, 3, states_5, "\000\010\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, - {262, "funcdef", 0, 8, states_6, - "\000\000\020\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, - {263, "parameters", 0, 4, states_7, - "\000\040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, - {264, "typedargslist", 0, 18, states_8, - "\000\000\040\200\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, - {265, "tfpdef", 0, 4, states_9, + {262, "async_funcdef", 0, 3, states_6, "\000\000\040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, - {266, "varargslist", 0, 18, states_10, - "\000\000\040\200\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, - {267, "vfpdef", 0, 2, states_11, - "\000\000\040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, - {268, "stmt", 0, 2, states_12, - "\000\050\060\200\000\000\000\240\340\223\160\220\045\200\020\000\000\206\120\076\204\000"}, - {269, "simple_stmt", 0, 4, states_13, - "\000\040\040\200\000\000\000\240\340\223\160\000\000\200\020\000\000\206\120\076\200\000"}, - {270, "small_stmt", 0, 2, states_14, - "\000\040\040\200\000\000\000\240\340\223\160\000\000\200\020\000\000\206\120\076\200\000"}, - {271, "expr_stmt", 0, 6, states_15, - "\000\040\040\200\000\000\000\000\000\200\000\000\000\200\020\000\000\206\120\076\000\000"}, - {272, "testlist_star_expr", 0, 3, states_16, - "\000\040\040\200\000\000\000\000\000\200\000\000\000\200\020\000\000\206\120\076\000\000"}, - {273, "augassign", 0, 2, states_17, - "\000\000\000\000\000\000\376\037\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, - {274, "del_stmt", 0, 3, states_18, - "\000\000\000\000\000\000\000\040\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, - {275, "pass_stmt", 0, 2, states_19, - "\000\000\000\000\000\000\000\200\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, - {276, "flow_stmt", 0, 2, states_20, - "\000\000\000\000\000\000\000\000\340\001\000\000\000\000\000\000\000\000\000\000\200\000"}, - {277, "break_stmt", 0, 2, states_21, - "\000\000\000\000\000\000\000\000\040\000\000\000\000\000\000\000\000\000\000\000\000\000"}, - {278, "continue_stmt", 0, 2, states_22, - "\000\000\000\000\000\000\000\000\100\000\000\000\000\000\000\000\000\000\000\000\000\000"}, - {279, "return_stmt", 0, 3, states_23, - "\000\000\000\000\000\000\000\000\200\000\000\000\000\000\000\000\000\000\000\000\000\000"}, - {280, "yield_stmt", 0, 2, states_24, - "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\200\000"}, - {281, "raise_stmt", 0, 5, states_25, + {263, "funcdef", 0, 8, states_7, + "\000\000\100\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, + {264, "parameters", 0, 4, states_8, + "\000\040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, + {265, "typedargslist", 0, 18, states_9, + "\000\000\200\000\006\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, + {266, "tfpdef", 0, 4, states_10, + "\000\000\200\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, + {267, "varargslist", 0, 18, states_11, + "\000\000\200\000\006\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, + {268, "vfpdef", 0, 2, states_12, + "\000\000\200\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, + {269, "stmt", 0, 2, states_13, + "\000\050\340\000\002\000\000\000\005\237\204\003\131\002\010\001\000\140\110\224\017\041"}, + {270, "simple_stmt", 0, 4, states_14, + "\000\040\200\000\002\000\000\000\005\237\204\003\000\000\010\001\000\140\110\224\017\040"}, + {271, "small_stmt", 0, 2, states_15, + "\000\040\200\000\002\000\000\000\005\237\204\003\000\000\010\001\000\140\110\224\017\040"}, + {272, "expr_stmt", 0, 6, states_16, + "\000\040\200\000\002\000\000\000\000\000\004\000\000\000\010\001\000\140\110\224\017\000"}, + {273, "testlist_star_expr", 0, 3, states_17, + "\000\040\200\000\002\000\000\000\000\000\004\000\000\000\010\001\000\140\110\224\017\000"}, + {274, "augassign", 0, 2, states_18, + "\000\000\000\000\000\000\370\377\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, + {275, "del_stmt", 0, 3, states_19, + "\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000"}, + {276, "pass_stmt", 0, 2, states_20, + "\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000"}, + {277, "flow_stmt", 0, 2, states_21, + "\000\000\000\000\000\000\000\000\000\017\000\000\000\000\000\000\000\000\000\000\000\040"}, + {278, "break_stmt", 0, 2, states_22, "\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000"}, - {282, "import_stmt", 0, 2, states_26, - "\000\000\000\000\000\000\000\000\000\022\000\000\000\000\000\000\000\000\000\000\000\000"}, - {283, "import_name", 0, 3, states_27, - "\000\000\000\000\000\000\000\000\000\020\000\000\000\000\000\000\000\000\000\000\000\000"}, - {284, "import_from", 0, 8, states_28, + {279, "continue_stmt", 0, 2, states_23, "\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000"}, - {285, "import_as_name", 0, 4, states_29, - "\000\000\040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, - {286, "dotted_as_name", 0, 4, states_30, - "\000\000\040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, - {287, "import_as_names", 0, 3, states_31, - "\000\000\040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, - {288, "dotted_as_names", 0, 2, states_32, - "\000\000\040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, - {289, "dotted_name", 0, 2, states_33, + {280, "return_stmt", 0, 3, states_24, + "\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000"}, + {281, "yield_stmt", 0, 2, states_25, + "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\040"}, + {282, "raise_stmt", 0, 5, states_26, + "\000\000\000\000\000\000\000\000\000\010\000\000\000\000\000\000\000\000\000\000\000\000"}, + {283, "import_stmt", 0, 2, states_27, + "\000\000\000\000\000\000\000\000\000\220\000\000\000\000\000\000\000\000\000\000\000\000"}, + {284, "import_name", 0, 3, states_28, + "\000\000\000\000\000\000\000\000\000\200\000\000\000\000\000\000\000\000\000\000\000\000"}, + {285, "import_from", 0, 8, states_29, + "\000\000\000\000\000\000\000\000\000\020\000\000\000\000\000\000\000\000\000\000\000\000"}, + {286, "import_as_name", 0, 4, states_30, + "\000\000\200\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, + {287, "dotted_as_name", 0, 4, states_31, + "\000\000\200\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, + {288, "import_as_names", 0, 3, states_32, + "\000\000\200\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, + {289, "dotted_as_names", 0, 2, states_33, + "\000\000\200\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, + {290, "dotted_name", 0, 2, states_34, + "\000\000\200\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, + {291, "global_stmt", 0, 3, states_35, + "\000\000\000\000\000\000\000\000\000\000\200\000\000\000\000\000\000\000\000\000\000\000"}, + {292, "nonlocal_stmt", 0, 3, states_36, + "\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000"}, + {293, "assert_stmt", 0, 5, states_37, + "\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000"}, + {294, "compound_stmt", 0, 2, states_38, + "\000\010\140\000\000\000\000\000\000\000\000\000\131\002\000\000\000\000\000\000\000\001"}, + {295, "async_stmt", 0, 3, states_39, "\000\000\040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, - {290, "global_stmt", 0, 3, states_34, - "\000\000\000\000\000\000\000\000\000\000\020\000\000\000\000\000\000\000\000\000\000\000"}, - {291, "nonlocal_stmt", 0, 3, states_35, - "\000\000\000\000\000\000\000\000\000\000\040\000\000\000\000\000\000\000\000\000\000\000"}, - {292, "assert_stmt", 0, 5, states_36, - "\000\000\000\000\000\000\000\000\000\000\100\000\000\000\000\000\000\000\000\000\000\000"}, - {293, "compound_stmt", 0, 2, states_37, - "\000\010\020\000\000\000\000\000\000\000\000\220\045\000\000\000\000\000\000\000\004\000"}, - {294, "if_stmt", 0, 8, states_38, - "\000\000\000\000\000\000\000\000\000\000\000\020\000\000\000\000\000\000\000\000\000\000"}, - {295, "while_stmt", 0, 8, states_39, - "\000\000\000\000\000\000\000\000\000\000\000\200\000\000\000\000\000\000\000\000\000\000"}, - {296, "for_stmt", 0, 10, states_40, + {296, "if_stmt", 0, 8, states_40, "\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000"}, - {297, "try_stmt", 0, 13, states_41, - "\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000"}, - {298, "with_stmt", 0, 5, states_42, - "\000\000\000\000\000\000\000\000\000\000\000\000\040\000\000\000\000\000\000\000\000\000"}, - {299, "with_item", 0, 4, states_43, - "\000\040\040\000\000\000\000\000\000\200\000\000\000\200\020\000\000\206\120\076\000\000"}, - {300, "except_clause", 0, 5, states_44, - "\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000"}, - {301, "suite", 0, 5, states_45, - "\004\040\040\200\000\000\000\240\340\223\160\000\000\200\020\000\000\206\120\076\200\000"}, - {302, "test", 0, 6, states_46, - "\000\040\040\000\000\000\000\000\000\200\000\000\000\200\020\000\000\206\120\076\000\000"}, - {303, "test_nocond", 0, 2, states_47, - "\000\040\040\000\000\000\000\000\000\200\000\000\000\200\020\000\000\206\120\076\000\000"}, - {304, "lambdef", 0, 5, states_48, - "\000\000\000\000\000\000\000\000\000\000\000\000\000\200\000\000\000\000\000\000\000\000"}, - {305, "lambdef_nocond", 0, 5, states_49, - "\000\000\000\000\000\000\000\000\000\000\000\000\000\200\000\000\000\000\000\000\000\000"}, - {306, "or_test", 0, 2, states_50, - "\000\040\040\000\000\000\000\000\000\200\000\000\000\000\020\000\000\206\120\076\000\000"}, - {307, "and_test", 0, 2, states_51, - "\000\040\040\000\000\000\000\000\000\200\000\000\000\000\020\000\000\206\120\076\000\000"}, - {308, "not_test", 0, 3, states_52, - "\000\040\040\000\000\000\000\000\000\200\000\000\000\000\020\000\000\206\120\076\000\000"}, - {309, "comparison", 0, 2, states_53, - "\000\040\040\000\000\000\000\000\000\200\000\000\000\000\000\000\000\206\120\076\000\000"}, - {310, "comp_op", 0, 4, states_54, - "\000\000\000\000\000\000\000\000\000\000\000\000\002\000\220\177\000\000\000\000\000\000"}, - {311, "star_expr", 0, 3, states_55, - "\000\000\000\200\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, - {312, "expr", 0, 2, states_56, - "\000\040\040\000\000\000\000\000\000\200\000\000\000\000\000\000\000\206\120\076\000\000"}, - {313, "xor_expr", 0, 2, states_57, - "\000\040\040\000\000\000\000\000\000\200\000\000\000\000\000\000\000\206\120\076\000\000"}, - {314, "and_expr", 0, 2, states_58, - "\000\040\040\000\000\000\000\000\000\200\000\000\000\000\000\000\000\206\120\076\000\000"}, - {315, "shift_expr", 0, 2, states_59, - "\000\040\040\000\000\000\000\000\000\200\000\000\000\000\000\000\000\206\120\076\000\000"}, - {316, "arith_expr", 0, 2, states_60, - "\000\040\040\000\000\000\000\000\000\200\000\000\000\000\000\000\000\206\120\076\000\000"}, - {317, "term", 0, 2, states_61, - "\000\040\040\000\000\000\000\000\000\200\000\000\000\000\000\000\000\206\120\076\000\000"}, - {318, "factor", 0, 3, states_62, - "\000\040\040\000\000\000\000\000\000\200\000\000\000\000\000\000\000\206\120\076\000\000"}, - {319, "power", 0, 4, states_63, - "\000\040\040\000\000\000\000\000\000\200\000\000\000\000\000\000\000\000\120\076\000\000"}, - {320, "atom", 0, 9, states_64, - "\000\040\040\000\000\000\000\000\000\200\000\000\000\000\000\000\000\000\120\076\000\000"}, - {321, "testlist_comp", 0, 5, states_65, - "\000\040\040\200\000\000\000\000\000\200\000\000\000\200\020\000\000\206\120\076\000\000"}, - {322, "trailer", 0, 7, states_66, - "\000\040\000\000\000\000\000\000\000\100\000\000\000\000\000\000\000\000\020\000\000\000"}, - {323, "subscriptlist", 0, 3, states_67, - "\000\040\040\002\000\000\000\000\000\200\000\000\000\200\020\000\000\206\120\076\000\000"}, - {324, "subscript", 0, 5, states_68, - "\000\040\040\002\000\000\000\000\000\200\000\000\000\200\020\000\000\206\120\076\000\000"}, - {325, "sliceop", 0, 3, states_69, - "\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, - {326, "exprlist", 0, 3, states_70, - "\000\040\040\200\000\000\000\000\000\200\000\000\000\000\000\000\000\206\120\076\000\000"}, - {327, "testlist", 0, 3, states_71, - "\000\040\040\000\000\000\000\000\000\200\000\000\000\200\020\000\000\206\120\076\000\000"}, - {328, "dictorsetmaker", 0, 11, states_72, - "\000\040\040\000\000\000\000\000\000\200\000\000\000\200\020\000\000\206\120\076\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\004\000"}, - {330, "arglist", 0, 8, states_74, - "\000\040\040\200\001\000\000\000\000\200\000\000\000\200\020\000\000\206\120\076\000\000"}, - {331, "argument", 0, 4, states_75, - "\000\040\040\000\000\000\000\000\000\200\000\000\000\200\020\000\000\206\120\076\000\000"}, - {332, "comp_iter", 0, 2, states_76, - "\000\000\000\000\000\000\000\000\000\000\000\020\001\000\000\000\000\000\000\000\000\000"}, - {333, "comp_for", 0, 6, states_77, + {297, "while_stmt", 0, 8, states_41, + "\000\000\000\000\000\000\000\000\000\000\000\000\010\000\000\000\000\000\000\000\000\000"}, + {298, "for_stmt", 0, 10, states_42, + "\000\000\000\000\000\000\000\000\000\000\000\000\020\000\000\000\000\000\000\000\000\000"}, + {299, "try_stmt", 0, 13, states_43, + "\000\000\000\000\000\000\000\000\000\000\000\000\100\000\000\000\000\000\000\000\000\000"}, + {300, "with_stmt", 0, 5, states_44, + "\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000"}, + {301, "with_item", 0, 4, states_45, + "\000\040\200\000\000\000\000\000\000\000\004\000\000\000\010\001\000\140\110\224\017\000"}, + {302, "except_clause", 0, 5, states_46, + "\000\000\000\000\000\000\000\000\000\000\000\000\000\020\000\000\000\000\000\000\000\000"}, + {303, "suite", 0, 5, states_47, + "\004\040\200\000\002\000\000\000\005\237\204\003\000\000\010\001\000\140\110\224\017\040"}, + {304, "test", 0, 6, states_48, + "\000\040\200\000\000\000\000\000\000\000\004\000\000\000\010\001\000\140\110\224\017\000"}, + {305, "test_nocond", 0, 2, states_49, + "\000\040\200\000\000\000\000\000\000\000\004\000\000\000\010\001\000\140\110\224\017\000"}, + {306, "lambdef", 0, 5, states_50, + "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\010\000\000\000\000\000\000\000"}, + {307, "lambdef_nocond", 0, 5, states_51, + "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\010\000\000\000\000\000\000\000"}, + {308, "or_test", 0, 2, states_52, + "\000\040\200\000\000\000\000\000\000\000\004\000\000\000\000\001\000\140\110\224\017\000"}, + {309, "and_test", 0, 2, states_53, + "\000\040\200\000\000\000\000\000\000\000\004\000\000\000\000\001\000\140\110\224\017\000"}, + {310, "not_test", 0, 3, states_54, + "\000\040\200\000\000\000\000\000\000\000\004\000\000\000\000\001\000\140\110\224\017\000"}, + {311, "comparison", 0, 2, states_55, + "\000\040\200\000\000\000\000\000\000\000\004\000\000\000\000\000\000\140\110\224\017\000"}, + {312, "comp_op", 0, 4, states_56, + "\000\000\000\000\000\000\000\000\000\000\000\000\040\000\000\371\007\000\000\000\000\000"}, + {313, "star_expr", 0, 3, states_57, + "\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, + {314, "expr", 0, 2, states_58, + "\000\040\200\000\000\000\000\000\000\000\004\000\000\000\000\000\000\140\110\224\017\000"}, + {315, "xor_expr", 0, 2, states_59, + "\000\040\200\000\000\000\000\000\000\000\004\000\000\000\000\000\000\140\110\224\017\000"}, + {316, "and_expr", 0, 2, states_60, + "\000\040\200\000\000\000\000\000\000\000\004\000\000\000\000\000\000\140\110\224\017\000"}, + {317, "shift_expr", 0, 2, states_61, + "\000\040\200\000\000\000\000\000\000\000\004\000\000\000\000\000\000\140\110\224\017\000"}, + {318, "arith_expr", 0, 2, states_62, + "\000\040\200\000\000\000\000\000\000\000\004\000\000\000\000\000\000\140\110\224\017\000"}, + {319, "term", 0, 2, states_63, + "\000\040\200\000\000\000\000\000\000\000\004\000\000\000\000\000\000\140\110\224\017\000"}, + {320, "factor", 0, 3, states_64, + "\000\040\200\000\000\000\000\000\000\000\004\000\000\000\000\000\000\140\110\224\017\000"}, + {321, "power", 0, 4, states_65, + "\000\040\200\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\100\224\017\000"}, + {322, "atom_expr", 0, 3, states_66, + "\000\040\200\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\100\224\017\000"}, + {323, "atom", 0, 9, states_67, + "\000\040\200\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\224\017\000"}, + {324, "testlist_comp", 0, 5, states_68, + "\000\040\200\000\002\000\000\000\000\000\004\000\000\000\010\001\000\140\110\224\017\000"}, + {325, "trailer", 0, 7, states_69, + "\000\040\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\004\000\000"}, + {326, "subscriptlist", 0, 3, states_70, + "\000\040\200\010\000\000\000\000\000\000\004\000\000\000\010\001\000\140\110\224\017\000"}, + {327, "subscript", 0, 5, states_71, + "\000\040\200\010\000\000\000\000\000\000\004\000\000\000\010\001\000\140\110\224\017\000"}, + {328, "sliceop", 0, 3, states_72, + "\000\000\000\010\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, + {329, "exprlist", 0, 3, states_73, + "\000\040\200\000\002\000\000\000\000\000\004\000\000\000\000\000\000\140\110\224\017\000"}, + {330, "testlist", 0, 3, states_74, + "\000\040\200\000\000\000\000\000\000\000\004\000\000\000\010\001\000\140\110\224\017\000"}, + {331, "dictorsetmaker", 0, 14, states_75, + "\000\040\200\000\006\000\000\000\000\000\004\000\000\000\010\001\000\140\110\224\017\000"}, + {332, "classdef", 0, 8, states_76, + "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001"}, + {333, "arglist", 0, 3, states_77, + "\000\040\200\000\006\000\000\000\000\000\004\000\000\000\010\001\000\140\110\224\017\000"}, + {334, "argument", 0, 4, states_78, + "\000\040\200\000\006\000\000\000\000\000\004\000\000\000\010\001\000\140\110\224\017\000"}, + {335, "comp_iter", 0, 2, states_79, + "\000\000\000\000\000\000\000\000\000\000\000\000\021\000\000\000\000\000\000\000\000\000"}, + {336, "comp_for", 0, 6, states_80, + "\000\000\000\000\000\000\000\000\000\000\000\000\020\000\000\000\000\000\000\000\000\000"}, + {337, "comp_if", 0, 4, states_81, "\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000"}, - {334, "comp_if", 0, 4, states_78, - "\000\000\000\000\000\000\000\000\000\000\000\020\000\000\000\000\000\000\000\000\000\000"}, - {335, "encoding_decl", 0, 2, states_79, - "\000\000\040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, - {336, "yield_expr", 0, 3, states_80, - "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\200\000"}, - {337, "yield_arg", 0, 3, states_81, - "\000\040\040\000\000\000\000\000\000\202\000\000\000\200\020\000\000\206\120\076\000\000"}, -}; -static label labels[169] = { + {338, "encoding_decl", 0, 2, states_82, + "\000\000\200\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, + {339, "yield_expr", 0, 3, states_83, + "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\040"}, + {340, "yield_arg", 0, 3, states_84, + "\000\040\200\000\000\000\000\000\000\020\004\000\000\000\010\001\000\140\110\224\017\000"}, +}; +static label labels[175] = { {0, "EMPTY"}, {256, 0}, {4, 0}, - {269, 0}, - {293, 0}, + {270, 0}, + {294, 0}, {257, 0}, - {268, 0}, + {269, 0}, {0, 0}, {258, 0}, - {327, 0}, + {330, 0}, {259, 0}, {49, 0}, - {289, 0}, + {290, 0}, {7, 0}, - {330, 0}, + {333, 0}, {8, 0}, {260, 0}, {261, 0}, - {329, 0}, + {332, 0}, + {263, 0}, {262, 0}, + {55, 0}, {1, "def"}, {1, 0}, - {263, 0}, - {50, 0}, - {302, 0}, - {11, 0}, - {301, 0}, {264, 0}, + {51, 0}, + {304, 0}, + {11, 0}, + {303, 0}, {265, 0}, + {266, 0}, {22, 0}, {12, 0}, {16, 0}, {35, 0}, - {266, 0}, {267, 0}, - {270, 0}, - {13, 0}, + {268, 0}, {271, 0}, - {274, 0}, + {13, 0}, + {272, 0}, {275, 0}, {276, 0}, - {282, 0}, - {290, 0}, + {277, 0}, + {283, 0}, {291, 0}, {292, 0}, - {272, 0}, + {293, 0}, {273, 0}, - {336, 0}, - {311, 0}, + {274, 0}, + {339, 0}, + {313, 0}, {36, 0}, {37, 0}, {38, 0}, + {50, 0}, {39, 0}, {40, 0}, {41, 0}, @@ -2046,36 +2098,37 @@ static label labels[169] = { {46, 0}, {48, 0}, {1, "del"}, - {326, 0}, + {329, 0}, {1, "pass"}, - {277, 0}, {278, 0}, {279, 0}, - {281, 0}, {280, 0}, + {282, 0}, + {281, 0}, {1, "break"}, {1, "continue"}, {1, "return"}, {1, "raise"}, {1, "from"}, - {283, 0}, {284, 0}, + {285, 0}, {1, "import"}, - {288, 0}, + {289, 0}, {23, 0}, - {51, 0}, - {287, 0}, - {285, 0}, - {1, "as"}, + {52, 0}, + {288, 0}, {286, 0}, + {1, "as"}, + {287, 0}, {1, "global"}, {1, "nonlocal"}, {1, "assert"}, - {294, 0}, - {295, 0}, {296, 0}, {297, 0}, {298, 0}, + {299, 0}, + {300, 0}, + {295, 0}, {1, "if"}, {1, "elif"}, {1, "else"}, @@ -2083,26 +2136,26 @@ static label labels[169] = { {1, "for"}, {1, "in"}, {1, "try"}, - {300, 0}, + {302, 0}, {1, "finally"}, {1, "with"}, - {299, 0}, - {312, 0}, + {301, 0}, + {314, 0}, {1, "except"}, {5, 0}, {6, 0}, + {308, 0}, {306, 0}, - {304, 0}, - {303, 0}, {305, 0}, - {1, "lambda"}, {307, 0}, + {1, "lambda"}, + {309, 0}, {1, "or"}, - {308, 0}, + {310, 0}, {1, "and"}, {1, "not"}, - {309, 0}, - {310, 0}, + {311, 0}, + {312, 0}, {20, 0}, {21, 0}, {27, 0}, @@ -2111,52 +2164,54 @@ static label labels[169] = { {28, 0}, {28, 0}, {1, "is"}, - {313, 0}, + {315, 0}, {18, 0}, - {314, 0}, + {316, 0}, {32, 0}, - {315, 0}, + {317, 0}, {19, 0}, - {316, 0}, + {318, 0}, {33, 0}, {34, 0}, - {317, 0}, + {319, 0}, {14, 0}, {15, 0}, - {318, 0}, + {320, 0}, {17, 0}, {24, 0}, {47, 0}, {31, 0}, - {319, 0}, - {320, 0}, - {322, 0}, {321, 0}, + {322, 0}, + {54, 0}, + {323, 0}, + {325, 0}, + {324, 0}, {9, 0}, {10, 0}, {25, 0}, - {328, 0}, + {331, 0}, {26, 0}, {2, 0}, {3, 0}, {1, "None"}, {1, "True"}, {1, "False"}, - {333, 0}, - {323, 0}, - {324, 0}, - {325, 0}, + {336, 0}, + {326, 0}, + {327, 0}, + {328, 0}, {1, "class"}, - {331, 0}, - {332, 0}, {334, 0}, {335, 0}, - {1, "yield"}, {337, 0}, + {338, 0}, + {1, "yield"}, + {340, 0}, }; grammar _PyParser_Grammar = { - 82, + 85, dfas, - {169, labels}, + {175, labels}, 256 }; diff --git a/Python/import.c b/Python/import.c index 4f0765a13a..edf030d87a 100644 --- a/Python/import.c +++ b/Python/import.c @@ -36,6 +36,8 @@ module _imp [clinic start generated code]*/ /*[clinic end generated code: output=da39a3ee5e6b4b0d input=9c332475d8686284]*/ +#include "clinic/import.c.h" + /*[python input] class fs_unicode_converter(CConverter): type = 'PyObject *' @@ -239,29 +241,9 @@ Return True if the import lock is currently held, else False. On platforms without threads, return False. [clinic start generated code]*/ -PyDoc_STRVAR(_imp_lock_held__doc__, -"lock_held($module, /)\n" -"--\n" -"\n" -"Return True if the import lock is currently held, else False.\n" -"\n" -"On platforms without threads, return False."); - -#define _IMP_LOCK_HELD_METHODDEF \ - {"lock_held", (PyCFunction)_imp_lock_held, METH_NOARGS, _imp_lock_held__doc__}, - -static PyObject * -_imp_lock_held_impl(PyModuleDef *module); - -static PyObject * -_imp_lock_held(PyModuleDef *module, PyObject *Py_UNUSED(ignored)) -{ - return _imp_lock_held_impl(module); -} - static PyObject * _imp_lock_held_impl(PyModuleDef *module) -/*[clinic end generated code: output=dae65674966baa65 input=9b088f9b217d9bdf]*/ +/*[clinic end generated code: output=d7a8cc3a5169081a input=9b088f9b217d9bdf]*/ { #ifdef WITH_THREAD return PyBool_FromLong(import_lock_thread != -1); @@ -279,30 +261,9 @@ This lock should be used by import hooks to ensure thread-safety when importing modules. On platforms without threads, this function does nothing. [clinic start generated code]*/ -PyDoc_STRVAR(_imp_acquire_lock__doc__, -"acquire_lock($module, /)\n" -"--\n" -"\n" -"Acquires the interpreter\'s import lock for the current thread.\n" -"\n" -"This lock should be used by import hooks to ensure thread-safety when importing\n" -"modules. On platforms without threads, this function does nothing."); - -#define _IMP_ACQUIRE_LOCK_METHODDEF \ - {"acquire_lock", (PyCFunction)_imp_acquire_lock, METH_NOARGS, _imp_acquire_lock__doc__}, - -static PyObject * -_imp_acquire_lock_impl(PyModuleDef *module); - -static PyObject * -_imp_acquire_lock(PyModuleDef *module, PyObject *Py_UNUSED(ignored)) -{ - return _imp_acquire_lock_impl(module); -} - static PyObject * _imp_acquire_lock_impl(PyModuleDef *module) -/*[clinic end generated code: output=478f1fa089fdb9a4 input=4a2d4381866d5fdc]*/ +/*[clinic end generated code: output=cc143b1d16422cae input=4a2d4381866d5fdc]*/ { #ifdef WITH_THREAD _PyImport_AcquireLock(); @@ -319,29 +280,9 @@ Release the interpreter's import lock. On platforms without threads, this function does nothing. [clinic start generated code]*/ -PyDoc_STRVAR(_imp_release_lock__doc__, -"release_lock($module, /)\n" -"--\n" -"\n" -"Release the interpreter\'s import lock.\n" -"\n" -"On platforms without threads, this function does nothing."); - -#define _IMP_RELEASE_LOCK_METHODDEF \ - {"release_lock", (PyCFunction)_imp_release_lock, METH_NOARGS, _imp_release_lock__doc__}, - -static PyObject * -_imp_release_lock_impl(PyModuleDef *module); - -static PyObject * -_imp_release_lock(PyModuleDef *module, PyObject *Py_UNUSED(ignored)) -{ - return _imp_release_lock_impl(module); -} - static PyObject * _imp_release_lock_impl(PyModuleDef *module) -/*[clinic end generated code: output=36c77a6832fdafd4 input=934fb11516dd778b]*/ +/*[clinic end generated code: output=74d28e38ebe2b224 input=934fb11516dd778b]*/ { #ifdef WITH_THREAD if (_PyImport_ReleaseLock() < 0) { @@ -550,8 +491,13 @@ PyImport_GetMagicNumber(void) { long res; PyInterpreterState *interp = PyThreadState_Get()->interp; - PyObject *pyc_magic = PyObject_GetAttrString(interp->importlib, - "_RAW_MAGIC_NUMBER"); + PyObject *external, *pyc_magic; + + external = PyObject_GetAttrString(interp->importlib, "_bootstrap_external"); + if (external == NULL) + return -1; + pyc_magic = PyObject_GetAttrString(external, "_RAW_MAGIC_NUMBER"); + Py_DECREF(external); if (pyc_magic == NULL) return -1; res = PyLong_AsLong(pyc_magic); @@ -796,7 +742,7 @@ PyImport_ExecCodeModuleWithPathnames(const char *name, PyObject *co, const char *cpathname) { PyObject *m = NULL; - PyObject *nameobj, *pathobj = NULL, *cpathobj = NULL; + PyObject *nameobj, *pathobj = NULL, *cpathobj = NULL, *external= NULL; nameobj = PyUnicode_FromString(name); if (nameobj == NULL) @@ -824,9 +770,14 @@ PyImport_ExecCodeModuleWithPathnames(const char *name, PyObject *co, "no interpreter!"); } - pathobj = _PyObject_CallMethodIdObjArgs(interp->importlib, - &PyId__get_sourcefile, cpathobj, - NULL); + external= PyObject_GetAttrString(interp->importlib, + "_bootstrap_external"); + if (external != NULL) { + pathobj = _PyObject_CallMethodIdObjArgs(external, + &PyId__get_sourcefile, cpathobj, + NULL); + Py_DECREF(external); + } if (pathobj == NULL) PyErr_Clear(); } @@ -892,7 +843,7 @@ PyObject* PyImport_ExecCodeModuleObject(PyObject *name, PyObject *co, PyObject *pathname, PyObject *cpathname) { - PyObject *d, *res; + PyObject *d, *external, *res; PyInterpreterState *interp = PyThreadState_GET()->interp; _Py_IDENTIFIER(_fix_up_module); @@ -904,9 +855,13 @@ PyImport_ExecCodeModuleObject(PyObject *name, PyObject *co, PyObject *pathname, if (pathname == NULL) { pathname = ((PyCodeObject *)co)->co_filename; } - res = _PyObject_CallMethodIdObjArgs(interp->importlib, + external = PyObject_GetAttrString(interp->importlib, "_bootstrap_external"); + if (external == NULL) + return NULL; + res = _PyObject_CallMethodIdObjArgs(external, &PyId__fix_up_module, d, name, pathname, cpathname, NULL); + Py_DECREF(external); if (res != NULL) { Py_DECREF(res); res = exec_code_in_module(name, d, co); @@ -966,43 +921,10 @@ _imp._fix_co_filename Changes code.co_filename to specify the passed-in file path. [clinic start generated code]*/ -PyDoc_STRVAR(_imp__fix_co_filename__doc__, -"_fix_co_filename($module, code, path, /)\n" -"--\n" -"\n" -"Changes code.co_filename to specify the passed-in file path.\n" -"\n" -" code\n" -" Code object to change.\n" -" path\n" -" File path to use."); - -#define _IMP__FIX_CO_FILENAME_METHODDEF \ - {"_fix_co_filename", (PyCFunction)_imp__fix_co_filename, METH_VARARGS, _imp__fix_co_filename__doc__}, - -static PyObject * -_imp__fix_co_filename_impl(PyModuleDef *module, PyCodeObject *code, PyObject *path); - -static PyObject * -_imp__fix_co_filename(PyModuleDef *module, PyObject *args) -{ - PyObject *return_value = NULL; - PyCodeObject *code; - PyObject *path; - - if (!PyArg_ParseTuple(args, - "O!U:_fix_co_filename", - &PyCode_Type, &code, &path)) - goto exit; - return_value = _imp__fix_co_filename_impl(module, code, path); - -exit: - return return_value; -} - static PyObject * -_imp__fix_co_filename_impl(PyModuleDef *module, PyCodeObject *code, PyObject *path) -/*[clinic end generated code: output=6b4b1edeb0d55c5d input=895ba50e78b82f05]*/ +_imp__fix_co_filename_impl(PyModuleDef *module, PyCodeObject *code, + PyObject *path) +/*[clinic end generated code: output=f4db56aac0a1327f input=895ba50e78b82f05]*/ { update_compiled_module(code, path); @@ -1104,50 +1026,74 @@ PyImport_GetImporter(PyObject *path) { return importer; } +/*[clinic input] +_imp.create_builtin -static int init_builtin(PyObject *); /* Forward */ + spec: object + / -/* Initialize a built-in module. - Return 1 for success, 0 if the module is not found, and -1 with - an exception set if the initialization failed. */ +Create an extension module. +[clinic start generated code]*/ -static int -init_builtin(PyObject *name) +static PyObject * +_imp_create_builtin(PyModuleDef *module, PyObject *spec) +/*[clinic end generated code: output=5038f467617226bd input=37f966f890384e47]*/ { struct _inittab *p; + PyObject *name; + char *namestr; PyObject *mod; + name = PyObject_GetAttrString(spec, "name"); + if (name == NULL) { + return NULL; + } + mod = _PyImport_FindExtensionObject(name, name); - if (PyErr_Occurred()) - return -1; - if (mod != NULL) - return 1; + if (mod || PyErr_Occurred()) { + Py_DECREF(name); + Py_INCREF(mod); + return mod; + } + + namestr = PyUnicode_AsUTF8(name); + if (namestr == NULL) { + Py_DECREF(name); + return NULL; + } for (p = PyImport_Inittab; p->name != NULL; p++) { - PyObject *mod; PyModuleDef *def; if (PyUnicode_CompareWithASCIIString(name, p->name) == 0) { if (p->initfunc == NULL) { - PyErr_Format(PyExc_ImportError, - "Cannot re-init internal module %R", - name); - return -1; + /* Cannot re-init internal module ("sys" or "builtins") */ + mod = PyImport_AddModule(namestr); + Py_DECREF(name); + return mod; } mod = (*p->initfunc)(); - if (mod == 0) - return -1; - /* Remember pointer to module init function. */ - def = PyModule_GetDef(mod); - def->m_base.m_init = p->initfunc; - if (_PyImport_FixupExtensionObject(mod, name, name) < 0) - return -1; - /* FixupExtension has put the module into sys.modules, - so we can release our own reference. */ - Py_DECREF(mod); - return 1; + if (mod == NULL) { + Py_DECREF(name); + return NULL; + } + if (PyObject_TypeCheck(mod, &PyModuleDef_Type)) { + Py_DECREF(name); + return PyModule_FromDefAndSpec((PyModuleDef*)mod, spec); + } else { + /* Remember pointer to module init function. */ + def = PyModule_GetDef(mod); + def->m_base.m_init = p->initfunc; + if (_PyImport_FixupExtensionObject(mod, name, name) < 0) { + Py_DECREF(name); + return NULL; + } + Py_DECREF(name); + return mod; + } } } - return 0; + Py_DECREF(name); + Py_RETURN_NONE; } @@ -1337,6 +1283,7 @@ static void remove_importlib_frames(void) { const char *importlib_filename = "<frozen importlib._bootstrap>"; + const char *external_filename = "<frozen importlib._bootstrap_external>"; const char *remove_frames = "_call_with_frames_removed"; int always_trim = 0; int in_importlib = 0; @@ -1366,7 +1313,10 @@ remove_importlib_frames(void) assert(PyTraceBack_Check(tb)); now_in_importlib = (PyUnicode_CompareWithASCIIString( code->co_filename, - importlib_filename) == 0); + importlib_filename) == 0) || + (PyUnicode_CompareWithASCIIString( + code->co_filename, + external_filename) == 0); if (now_in_importlib && !in_importlib) { /* This is the link to this chunk of importlib tracebacks */ outer_link = prev_link; @@ -1868,27 +1818,9 @@ _imp.extension_suffixes Returns the list of file suffixes used to identify extension modules. [clinic start generated code]*/ -PyDoc_STRVAR(_imp_extension_suffixes__doc__, -"extension_suffixes($module, /)\n" -"--\n" -"\n" -"Returns the list of file suffixes used to identify extension modules."); - -#define _IMP_EXTENSION_SUFFIXES_METHODDEF \ - {"extension_suffixes", (PyCFunction)_imp_extension_suffixes, METH_NOARGS, _imp_extension_suffixes__doc__}, - -static PyObject * -_imp_extension_suffixes_impl(PyModuleDef *module); - -static PyObject * -_imp_extension_suffixes(PyModuleDef *module, PyObject *Py_UNUSED(ignored)) -{ - return _imp_extension_suffixes_impl(module); -} - static PyObject * _imp_extension_suffixes_impl(PyModuleDef *module) -/*[clinic end generated code: output=bb30a2438167798c input=ecdeeecfcb6f839e]*/ +/*[clinic end generated code: output=d44c1566ef362229 input=ecdeeecfcb6f839e]*/ { PyObject *list; const char *suffix; @@ -1917,62 +1849,6 @@ _imp_extension_suffixes_impl(PyModuleDef *module) } /*[clinic input] -_imp.init_builtin - - name: unicode - / - -Initializes a built-in module. -[clinic start generated code]*/ - -PyDoc_STRVAR(_imp_init_builtin__doc__, -"init_builtin($module, name, /)\n" -"--\n" -"\n" -"Initializes a built-in module."); - -#define _IMP_INIT_BUILTIN_METHODDEF \ - {"init_builtin", (PyCFunction)_imp_init_builtin, METH_VARARGS, _imp_init_builtin__doc__}, - -static PyObject * -_imp_init_builtin_impl(PyModuleDef *module, PyObject *name); - -static PyObject * -_imp_init_builtin(PyModuleDef *module, PyObject *args) -{ - PyObject *return_value = NULL; - PyObject *name; - - if (!PyArg_ParseTuple(args, - "U:init_builtin", - &name)) - goto exit; - return_value = _imp_init_builtin_impl(module, name); - -exit: - return return_value; -} - -static PyObject * -_imp_init_builtin_impl(PyModuleDef *module, PyObject *name) -/*[clinic end generated code: output=a0244948a43f8e26 input=f934d2231ec52a2e]*/ -{ - int ret; - PyObject *m; - - ret = init_builtin(name); - if (ret < 0) - return NULL; - if (ret == 0) { - Py_INCREF(Py_None); - return Py_None; - } - m = PyImport_AddModuleObject(name); - Py_XINCREF(m); - return m; -} - -/*[clinic input] _imp.init_frozen name: unicode @@ -1981,37 +1857,9 @@ _imp.init_frozen Initializes a frozen module. [clinic start generated code]*/ -PyDoc_STRVAR(_imp_init_frozen__doc__, -"init_frozen($module, name, /)\n" -"--\n" -"\n" -"Initializes a frozen module."); - -#define _IMP_INIT_FROZEN_METHODDEF \ - {"init_frozen", (PyCFunction)_imp_init_frozen, METH_VARARGS, _imp_init_frozen__doc__}, - -static PyObject * -_imp_init_frozen_impl(PyModuleDef *module, PyObject *name); - -static PyObject * -_imp_init_frozen(PyModuleDef *module, PyObject *args) -{ - PyObject *return_value = NULL; - PyObject *name; - - if (!PyArg_ParseTuple(args, - "U:init_frozen", - &name)) - goto exit; - return_value = _imp_init_frozen_impl(module, name); - -exit: - return return_value; -} - static PyObject * _imp_init_frozen_impl(PyModuleDef *module, PyObject *name) -/*[clinic end generated code: output=e4bc2bff296f8f22 input=13019adfc04f3fb3]*/ +/*[clinic end generated code: output=a9de493bdd711878 input=13019adfc04f3fb3]*/ { int ret; PyObject *m; @@ -2037,37 +1885,9 @@ _imp.get_frozen_object Create a code object for a frozen module. [clinic start generated code]*/ -PyDoc_STRVAR(_imp_get_frozen_object__doc__, -"get_frozen_object($module, name, /)\n" -"--\n" -"\n" -"Create a code object for a frozen module."); - -#define _IMP_GET_FROZEN_OBJECT_METHODDEF \ - {"get_frozen_object", (PyCFunction)_imp_get_frozen_object, METH_VARARGS, _imp_get_frozen_object__doc__}, - -static PyObject * -_imp_get_frozen_object_impl(PyModuleDef *module, PyObject *name); - -static PyObject * -_imp_get_frozen_object(PyModuleDef *module, PyObject *args) -{ - PyObject *return_value = NULL; - PyObject *name; - - if (!PyArg_ParseTuple(args, - "U:get_frozen_object", - &name)) - goto exit; - return_value = _imp_get_frozen_object_impl(module, name); - -exit: - return return_value; -} - static PyObject * _imp_get_frozen_object_impl(PyModuleDef *module, PyObject *name) -/*[clinic end generated code: output=4089ec702a9d70c5 input=ed689bc05358fdbd]*/ +/*[clinic end generated code: output=3114c970a47f2e3c input=ed689bc05358fdbd]*/ { return get_frozen_object(name); } @@ -2081,37 +1901,9 @@ _imp.is_frozen_package Returns True if the module name is of a frozen package. [clinic start generated code]*/ -PyDoc_STRVAR(_imp_is_frozen_package__doc__, -"is_frozen_package($module, name, /)\n" -"--\n" -"\n" -"Returns True if the module name is of a frozen package."); - -#define _IMP_IS_FROZEN_PACKAGE_METHODDEF \ - {"is_frozen_package", (PyCFunction)_imp_is_frozen_package, METH_VARARGS, _imp_is_frozen_package__doc__}, - -static PyObject * -_imp_is_frozen_package_impl(PyModuleDef *module, PyObject *name); - -static PyObject * -_imp_is_frozen_package(PyModuleDef *module, PyObject *args) -{ - PyObject *return_value = NULL; - PyObject *name; - - if (!PyArg_ParseTuple(args, - "U:is_frozen_package", - &name)) - goto exit; - return_value = _imp_is_frozen_package_impl(module, name); - -exit: - return return_value; -} - static PyObject * _imp_is_frozen_package_impl(PyModuleDef *module, PyObject *name) -/*[clinic end generated code: output=86aab14dcd4b959b input=81b6cdecd080fbb8]*/ +/*[clinic end generated code: output=3e4cab802b56d649 input=81b6cdecd080fbb8]*/ { return is_frozen_package(name); } @@ -2125,37 +1917,9 @@ _imp.is_builtin Returns True if the module name corresponds to a built-in module. [clinic start generated code]*/ -PyDoc_STRVAR(_imp_is_builtin__doc__, -"is_builtin($module, name, /)\n" -"--\n" -"\n" -"Returns True if the module name corresponds to a built-in module."); - -#define _IMP_IS_BUILTIN_METHODDEF \ - {"is_builtin", (PyCFunction)_imp_is_builtin, METH_VARARGS, _imp_is_builtin__doc__}, - -static PyObject * -_imp_is_builtin_impl(PyModuleDef *module, PyObject *name); - -static PyObject * -_imp_is_builtin(PyModuleDef *module, PyObject *args) -{ - PyObject *return_value = NULL; - PyObject *name; - - if (!PyArg_ParseTuple(args, - "U:is_builtin", - &name)) - goto exit; - return_value = _imp_is_builtin_impl(module, name); - -exit: - return return_value; -} - static PyObject * _imp_is_builtin_impl(PyModuleDef *module, PyObject *name) -/*[clinic end generated code: output=d5847f8cac50946e input=86befdac021dd1c7]*/ +/*[clinic end generated code: output=2deec9cac6fb9a7e input=86befdac021dd1c7]*/ { return PyLong_FromLong(is_builtin(name)); } @@ -2169,37 +1933,9 @@ _imp.is_frozen Returns True if the module name corresponds to a frozen module. [clinic start generated code]*/ -PyDoc_STRVAR(_imp_is_frozen__doc__, -"is_frozen($module, name, /)\n" -"--\n" -"\n" -"Returns True if the module name corresponds to a frozen module."); - -#define _IMP_IS_FROZEN_METHODDEF \ - {"is_frozen", (PyCFunction)_imp_is_frozen, METH_VARARGS, _imp_is_frozen__doc__}, - -static PyObject * -_imp_is_frozen_impl(PyModuleDef *module, PyObject *name); - -static PyObject * -_imp_is_frozen(PyModuleDef *module, PyObject *args) -{ - PyObject *return_value = NULL; - PyObject *name; - - if (!PyArg_ParseTuple(args, - "U:is_frozen", - &name)) - goto exit; - return_value = _imp_is_frozen_impl(module, name); - -exit: - return return_value; -} - static PyObject * _imp_is_frozen_impl(PyModuleDef *module, PyObject *name) -/*[clinic end generated code: output=6691af884ba4987d input=7301dbca1897d66b]*/ +/*[clinic end generated code: output=7de8e260c8e36aed input=7301dbca1897d66b]*/ { const struct _frozen *p; @@ -2207,84 +1943,131 @@ _imp_is_frozen_impl(PyModuleDef *module, PyObject *name) return PyBool_FromLong((long) (p == NULL ? 0 : p->size)); } +/* Common implementation for _imp.exec_dynamic and _imp.exec_builtin */ +static int +exec_builtin_or_dynamic(PyObject *mod) { + PyModuleDef *def; + void *state; + + if (!PyModule_Check(mod)) { + return 0; + } + + def = PyModule_GetDef(mod); + if (def == NULL) { + if (PyErr_Occurred()) { + return -1; + } + return 0; + } + state = PyModule_GetState(mod); + if (PyErr_Occurred()) { + return -1; + } + if (state) { + /* Already initialized; skip reload */ + return 0; + } + return PyModule_ExecDef(mod, def); +} + #ifdef HAVE_DYNAMIC_LOADING /*[clinic input] -_imp.load_dynamic +_imp.create_dynamic - name: unicode - path: fs_unicode + spec: object file: object = NULL / -Loads an extension module. +Create an extension module. [clinic start generated code]*/ -PyDoc_STRVAR(_imp_load_dynamic__doc__, -"load_dynamic($module, name, path, file=None, /)\n" -"--\n" -"\n" -"Loads an extension module."); - -#define _IMP_LOAD_DYNAMIC_METHODDEF \ - {"load_dynamic", (PyCFunction)_imp_load_dynamic, METH_VARARGS, _imp_load_dynamic__doc__}, - static PyObject * -_imp_load_dynamic_impl(PyModuleDef *module, PyObject *name, PyObject *path, PyObject *file); - -static PyObject * -_imp_load_dynamic(PyModuleDef *module, PyObject *args) +_imp_create_dynamic_impl(PyModuleDef *module, PyObject *spec, PyObject *file) +/*[clinic end generated code: output=935cde5b3872d56d input=c31b954f4cf4e09d]*/ { - PyObject *return_value = NULL; - PyObject *name; - PyObject *path; - PyObject *file = NULL; + PyObject *mod, *name, *path; + FILE *fp; - if (!PyArg_ParseTuple(args, - "UO&|O:load_dynamic", - &name, PyUnicode_FSDecoder, &path, &file)) - goto exit; - return_value = _imp_load_dynamic_impl(module, name, path, file); + name = PyObject_GetAttrString(spec, "name"); + if (name == NULL) { + return NULL; + } -exit: - return return_value; -} + path = PyObject_GetAttrString(spec, "origin"); + if (path == NULL) { + Py_DECREF(name); + return NULL; + } -static PyObject * -_imp_load_dynamic_impl(PyModuleDef *module, PyObject *name, PyObject *path, PyObject *file) -/*[clinic end generated code: output=81d11a1fbd1ea0a8 input=af64f06e4bad3526]*/ -{ - PyObject *mod; - FILE *fp; + mod = _PyImport_FindExtensionObject(name, path); + if (mod != NULL) { + Py_DECREF(name); + Py_DECREF(path); + Py_INCREF(mod); + return mod; + } if (file != NULL) { fp = _Py_fopen_obj(path, "r"); if (fp == NULL) { + Py_DECREF(name); Py_DECREF(path); - if (!PyErr_Occurred()) - PyErr_SetFromErrno(PyExc_IOError); return NULL; } } else fp = NULL; - mod = _PyImport_LoadDynamicModule(name, path, fp); + + mod = _PyImport_LoadDynamicModuleWithSpec(spec, fp); + + Py_DECREF(name); Py_DECREF(path); if (fp) fclose(fp); return mod; } +/*[clinic input] +_imp.exec_dynamic -> int + + mod: object + / + +Initialize an extension module. +[clinic start generated code]*/ + +static int +_imp_exec_dynamic_impl(PyModuleDef *module, PyObject *mod) +/*[clinic end generated code: output=4b84f1301b22d4bd input=9fdbfcb250280d3a]*/ +{ + return exec_builtin_or_dynamic(mod); +} + + #endif /* HAVE_DYNAMIC_LOADING */ /*[clinic input] -dump buffer +_imp.exec_builtin -> int + + mod: object + / + +Initialize a built-in module. [clinic start generated code]*/ -#ifndef _IMP_LOAD_DYNAMIC_METHODDEF - #define _IMP_LOAD_DYNAMIC_METHODDEF -#endif /* !defined(_IMP_LOAD_DYNAMIC_METHODDEF) */ -/*[clinic end generated code: output=d07c1d4a343a9579 input=524ce2e021e4eba6]*/ +static int +_imp_exec_builtin_impl(PyModuleDef *module, PyObject *mod) +/*[clinic end generated code: output=215e99876a27e284 input=7beed5a2f12a60ca]*/ +{ + return exec_builtin_or_dynamic(mod); +} + +/*[clinic input] +dump buffer +[clinic start generated code]*/ +/*[clinic end generated code: output=da39a3ee5e6b4b0d input=524ce2e021e4eba6]*/ PyDoc_STRVAR(doc_imp, @@ -2297,11 +2080,13 @@ static PyMethodDef imp_methods[] = { _IMP_RELEASE_LOCK_METHODDEF _IMP_GET_FROZEN_OBJECT_METHODDEF _IMP_IS_FROZEN_PACKAGE_METHODDEF - _IMP_INIT_BUILTIN_METHODDEF + _IMP_CREATE_BUILTIN_METHODDEF _IMP_INIT_FROZEN_METHODDEF _IMP_IS_BUILTIN_METHODDEF _IMP_IS_FROZEN_METHODDEF - _IMP_LOAD_DYNAMIC_METHODDEF + _IMP_CREATE_DYNAMIC_METHODDEF + _IMP_EXEC_DYNAMIC_METHODDEF + _IMP_EXEC_BUILTIN_METHODDEF _IMP__FIX_CO_FILENAME_METHODDEF {NULL, NULL} /* sentinel */ }; @@ -2384,7 +2169,7 @@ PyImport_AppendInittab(const char *name, PyObject* (*initfunc)(void)) memset(newtab, '\0', sizeof newtab); - newtab[0].name = (char *)name; + newtab[0].name = name; newtab[0].initfunc = initfunc; return PyImport_ExtendInittab(newtab); @@ -2393,4 +2178,3 @@ PyImport_AppendInittab(const char *name, PyObject* (*initfunc)(void)) #ifdef __cplusplus } #endif - diff --git a/Python/importdl.c b/Python/importdl.c index b60f1c75fb..1aa585d5e8 100644 --- a/Python/importdl.c +++ b/Python/importdl.c @@ -13,87 +13,185 @@ #include "importdl.h" #ifdef MS_WINDOWS -extern dl_funcptr _PyImport_GetDynLoadWindows(const char *shortname, - PyObject *pathname, FILE *fp); +extern dl_funcptr _PyImport_FindSharedFuncptrWindows(const char *prefix, + const char *shortname, + PyObject *pathname, + FILE *fp); #else -extern dl_funcptr _PyImport_GetDynLoadFunc(const char *shortname, - const char *pathname, FILE *fp); +extern dl_funcptr _PyImport_FindSharedFuncptr(const char *prefix, + const char *shortname, + const char *pathname, FILE *fp); #endif +static const char *ascii_only_prefix = "PyInit"; +static const char *nonascii_prefix = "PyInitU"; + +/* Get the variable part of a module's export symbol name. + * Returns a bytes instance. For non-ASCII-named modules, the name is + * encoded as per PEP 489. + * The hook_prefix pointer is set to either ascii_only_prefix or + * nonascii_prefix, as appropriate. + */ +static PyObject * +get_encoded_name(PyObject *name, const char **hook_prefix) { + PyObject *tmp; + PyObject *encoded = NULL; + PyObject *modname = NULL; + Py_ssize_t name_len, lastdot; + _Py_IDENTIFIER(replace); + + /* Get the short name (substring after last dot) */ + name_len = PyUnicode_GetLength(name); + lastdot = PyUnicode_FindChar(name, '.', 0, name_len, -1); + if (lastdot < -1) { + return NULL; + } else if (lastdot >= 0) { + tmp = PyUnicode_Substring(name, lastdot + 1, name_len); + if (tmp == NULL) + return NULL; + name = tmp; + /* "name" now holds a new reference to the substring */ + } else { + Py_INCREF(name); + } + + /* Encode to ASCII or Punycode, as needed */ + encoded = PyUnicode_AsEncodedString(name, "ascii", NULL); + if (encoded != NULL) { + *hook_prefix = ascii_only_prefix; + } else { + if (PyErr_ExceptionMatches(PyExc_UnicodeEncodeError)) { + PyErr_Clear(); + encoded = PyUnicode_AsEncodedString(name, "punycode", NULL); + if (encoded == NULL) { + goto error; + } + *hook_prefix = nonascii_prefix; + } else { + goto error; + } + } + + /* Replace '-' by '_' */ + modname = _PyObject_CallMethodId(encoded, &PyId_replace, "cc", '-', '_'); + if (modname == NULL) + goto error; + + Py_DECREF(name); + Py_DECREF(encoded); + return modname; +error: + Py_DECREF(name); + Py_XDECREF(encoded); + return NULL; +} + PyObject * -_PyImport_LoadDynamicModule(PyObject *name, PyObject *path, FILE *fp) +_PyImport_LoadDynamicModuleWithSpec(PyObject *spec, FILE *fp) { - PyObject *m = NULL; #ifndef MS_WINDOWS - PyObject *pathbytes; + PyObject *pathbytes = NULL; #endif - PyObject *nameascii; - char *namestr, *lastdot, *shortname, *packagecontext, *oldcontext; - dl_funcptr p0; - PyObject* (*p)(void); - struct PyModuleDef *def; - - m = _PyImport_FindExtensionObject(name, path); - if (m != NULL) { - Py_INCREF(m); - return m; - } - - /* name must be encodable to ASCII because dynamic module must have a - function called "PyInit_NAME", they are written in C, and the C language - doesn't accept non-ASCII identifiers. */ - nameascii = PyUnicode_AsEncodedString(name, "ascii", NULL); - if (nameascii == NULL) + PyObject *name_unicode = NULL, *name = NULL, *path = NULL, *m = NULL; + const char *name_buf, *hook_prefix; + char *oldcontext; + dl_funcptr exportfunc; + PyModuleDef *def; + PyObject *(*p0)(void); + + name_unicode = PyObject_GetAttrString(spec, "name"); + if (name_unicode == NULL) { return NULL; + } - namestr = PyBytes_AS_STRING(nameascii); - if (namestr == NULL) + name = get_encoded_name(name_unicode, &hook_prefix); + if (name == NULL) { goto error; - - lastdot = strrchr(namestr, '.'); - if (lastdot == NULL) { - packagecontext = NULL; - shortname = namestr; - } - else { - packagecontext = namestr; - shortname = lastdot+1; } + name_buf = PyBytes_AS_STRING(name); + + path = PyObject_GetAttrString(spec, "origin"); + if (path == NULL) + goto error; #ifdef MS_WINDOWS - p0 = _PyImport_GetDynLoadWindows(shortname, path, fp); + exportfunc = _PyImport_FindSharedFuncptrWindows(hook_prefix, name_buf, + path, fp); #else pathbytes = PyUnicode_EncodeFSDefault(path); if (pathbytes == NULL) goto error; - p0 = _PyImport_GetDynLoadFunc(shortname, - PyBytes_AS_STRING(pathbytes), fp); + exportfunc = _PyImport_FindSharedFuncptr(hook_prefix, name_buf, + PyBytes_AS_STRING(pathbytes), + fp); Py_DECREF(pathbytes); #endif - p = (PyObject*(*)(void))p0; - if (PyErr_Occurred()) - goto error; - if (p == NULL) { - PyObject *msg = PyUnicode_FromFormat("dynamic module does not define " - "init function (PyInit_%s)", - shortname); - if (msg == NULL) - goto error; - PyErr_SetImportError(msg, name, path); - Py_DECREF(msg); + + if (exportfunc == NULL) { + if (!PyErr_Occurred()) { + PyObject *msg; + msg = PyUnicode_FromFormat( + "dynamic module does not define " + "module export function (%s_%s)", + hook_prefix, name_buf); + if (msg == NULL) + goto error; + PyErr_SetImportError(msg, name_unicode, path); + Py_DECREF(msg); + } goto error; } + + p0 = (PyObject *(*)(void))exportfunc; + + /* Package context is needed for single-phase init */ oldcontext = _Py_PackageContext; - _Py_PackageContext = packagecontext; - m = (*p)(); + _Py_PackageContext = PyUnicode_AsUTF8(name_unicode); + m = p0(); _Py_PackageContext = oldcontext; - if (m == NULL) - goto error; - if (PyErr_Occurred()) { + if (m == NULL) { + if (!PyErr_Occurred()) { + PyErr_Format( + PyExc_SystemError, + "initialization of %s failed without raising an exception", + name_buf); + } + goto error; + } else if (PyErr_Occurred()) { + PyErr_Clear(); + PyErr_Format( + PyExc_SystemError, + "initialization of %s raised unreported exception", + name_buf); + m = NULL; + goto error; + } + if (Py_TYPE(m) == NULL) { + /* This can happen when a PyModuleDef is returned without calling + * PyModuleDef_Init on it + */ PyErr_Format(PyExc_SystemError, - "initialization of %s raised unreported exception", - shortname); + "init function of %s returned uninitialized object", + name_buf); + m = NULL; /* prevent segfault in DECREF */ + goto error; + } + if (PyObject_TypeCheck(m, &PyModuleDef_Type)) { + Py_DECREF(name_unicode); + Py_DECREF(name); + Py_DECREF(path); + return PyModule_FromDefAndSpec((PyModuleDef*)m, spec); + } + + /* Fall back to single-phase init mechanism */ + + if (hook_prefix == nonascii_prefix) { + /* don't allow legacy init for non-ASCII module names */ + PyErr_Format( + PyExc_SystemError, + "initialization of * did not return PyModuleDef", + name_buf); goto error; } @@ -102,10 +200,10 @@ _PyImport_LoadDynamicModule(PyObject *name, PyObject *path, FILE *fp) if (def == NULL) { PyErr_Format(PyExc_SystemError, "initialization of %s did not return an extension " - "module", shortname); + "module", name_buf); goto error; } - def->m_base.m_init = p; + def->m_base.m_init = p0; /* Remember the filename as the __file__ attribute */ if (PyModule_AddObject(m, "__file__", path) < 0) @@ -113,13 +211,19 @@ _PyImport_LoadDynamicModule(PyObject *name, PyObject *path, FILE *fp) else Py_INCREF(path); - if (_PyImport_FixupExtensionObject(m, name, path) < 0) + if (_PyImport_FixupExtensionObject(m, name_unicode, path) < 0) goto error; - Py_DECREF(nameascii); + + Py_DECREF(name_unicode); + Py_DECREF(name); + Py_DECREF(path); + return m; error: - Py_DECREF(nameascii); + Py_DECREF(name_unicode); + Py_XDECREF(name); + Py_XDECREF(path); Py_XDECREF(m); return NULL; } diff --git a/Python/importdl.h b/Python/importdl.h index 6a51a91d2c..9847652b1f 100644 --- a/Python/importdl.h +++ b/Python/importdl.h @@ -8,8 +8,7 @@ extern "C" { extern const char *_PyImport_DynLoadFiletab[]; -extern PyObject *_PyImport_LoadDynamicModule(PyObject *name, PyObject *pathname, - FILE *); +extern PyObject *_PyImport_LoadDynamicModuleWithSpec(PyObject *spec, FILE *); /* Max length of module suffix searched for -- accommodates "module.slb" */ #define MAXSUFFIXSIZE 12 diff --git a/Python/importlib.h b/Python/importlib.h index 75bfca405f..a4daf621e2 100644 --- a/Python/importlib.h +++ b/Python/importlib.h @@ -1,2263 +1,1452 @@ -/* Auto-generated by Modules/_freeze_importlib.c */ +/* Auto-generated by Programs/_freeze_importlib.c */ const unsigned char _Py_M__importlib[] = { - 99,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0, - 0,64,0,0,0,115,228,4,0,0,100,0,0,90,0,0, - 100,163,0,90,1,0,100,4,0,100,5,0,132,0,0,90, - 2,0,100,6,0,100,7,0,132,0,0,90,3,0,100,8, - 0,100,9,0,132,0,0,90,4,0,100,10,0,100,11,0, - 132,0,0,90,5,0,100,12,0,100,13,0,132,0,0,90, - 6,0,100,14,0,100,15,0,132,0,0,90,7,0,100,16, - 0,100,17,0,132,0,0,90,8,0,100,18,0,100,19,0, - 132,0,0,90,9,0,100,20,0,100,21,0,132,0,0,90, - 10,0,100,22,0,100,23,0,100,24,0,132,1,0,90,11, - 0,100,25,0,100,26,0,132,0,0,90,12,0,100,27,0, - 100,28,0,132,0,0,90,13,0,101,14,0,101,12,0,106, - 15,0,131,1,0,90,16,0,71,100,29,0,100,30,0,132, - 0,0,100,30,0,131,2,0,90,17,0,105,0,0,90,18, - 0,105,0,0,90,19,0,71,100,31,0,100,32,0,132,0, - 0,100,32,0,101,20,0,131,3,0,90,21,0,71,100,33, - 0,100,34,0,132,0,0,100,34,0,131,2,0,90,22,0, - 71,100,35,0,100,36,0,132,0,0,100,36,0,131,2,0, - 90,23,0,71,100,37,0,100,38,0,132,0,0,100,38,0, - 131,2,0,90,24,0,100,39,0,100,40,0,132,0,0,90, - 25,0,100,41,0,100,42,0,132,0,0,90,26,0,100,43, - 0,100,44,0,132,0,0,90,27,0,100,45,0,106,28,0, - 100,46,0,100,47,0,131,2,0,100,48,0,23,90,29,0, - 101,30,0,106,31,0,101,29,0,100,47,0,131,2,0,90, - 32,0,100,49,0,90,33,0,100,50,0,103,1,0,90,34, - 0,100,51,0,103,1,0,90,35,0,100,52,0,103,1,0, - 90,36,0,100,53,0,100,54,0,100,55,0,132,1,0,90, - 37,0,100,56,0,100,57,0,132,0,0,90,38,0,100,58, - 0,100,59,0,132,0,0,90,39,0,100,60,0,100,61,0, - 132,0,0,90,40,0,100,62,0,100,63,0,100,64,0,100, - 65,0,132,0,1,90,41,0,100,66,0,100,67,0,132,0, - 0,90,42,0,100,68,0,100,69,0,132,0,0,90,43,0, - 100,70,0,100,71,0,132,0,0,90,44,0,100,72,0,100, - 73,0,132,0,0,90,45,0,100,74,0,100,75,0,132,0, - 0,90,46,0,100,53,0,100,53,0,100,53,0,100,76,0, - 100,77,0,132,3,0,90,47,0,100,53,0,100,53,0,100, - 53,0,100,78,0,100,79,0,132,3,0,90,48,0,100,80, - 0,100,80,0,100,81,0,100,82,0,132,2,0,90,49,0, - 100,83,0,100,84,0,132,0,0,90,50,0,100,85,0,100, - 86,0,132,0,0,90,51,0,71,100,87,0,100,88,0,132, - 0,0,100,88,0,131,2,0,90,52,0,71,100,89,0,100, - 90,0,132,0,0,100,90,0,131,2,0,90,53,0,100,91, - 0,100,53,0,100,92,0,100,53,0,100,93,0,100,94,0, - 132,0,2,90,54,0,101,55,0,131,0,0,90,56,0,100, - 53,0,100,95,0,100,53,0,100,96,0,101,56,0,100,97, - 0,100,98,0,132,1,2,90,57,0,100,53,0,100,53,0, - 100,99,0,100,100,0,132,2,0,90,58,0,71,100,101,0, - 100,102,0,132,0,0,100,102,0,131,2,0,90,59,0,100, - 53,0,100,103,0,100,104,0,132,1,0,90,60,0,71,100, - 105,0,100,106,0,132,0,0,100,106,0,131,2,0,90,61, - 0,71,100,107,0,100,108,0,132,0,0,100,108,0,131,2, - 0,90,62,0,71,100,109,0,100,110,0,132,0,0,100,110, - 0,131,2,0,90,63,0,71,100,111,0,100,112,0,132,0, - 0,100,112,0,131,2,0,90,64,0,71,100,113,0,100,114, - 0,132,0,0,100,114,0,101,64,0,131,3,0,90,65,0, - 71,100,115,0,100,116,0,132,0,0,100,116,0,131,2,0, - 90,66,0,71,100,117,0,100,118,0,132,0,0,100,118,0, - 101,66,0,101,65,0,131,4,0,90,67,0,71,100,119,0, - 100,120,0,132,0,0,100,120,0,101,66,0,101,64,0,131, - 4,0,90,68,0,103,0,0,90,69,0,71,100,121,0,100, - 122,0,132,0,0,100,122,0,131,2,0,90,70,0,71,100, - 123,0,100,124,0,132,0,0,100,124,0,131,2,0,90,71, - 0,71,100,125,0,100,126,0,132,0,0,100,126,0,131,2, - 0,90,72,0,71,100,127,0,100,128,0,132,0,0,100,128, - 0,131,2,0,90,73,0,71,100,129,0,100,130,0,132,0, - 0,100,130,0,131,2,0,90,74,0,71,100,131,0,100,132, - 0,132,0,0,100,132,0,131,2,0,90,75,0,100,133,0, - 100,134,0,132,0,0,90,76,0,100,135,0,100,136,0,132, - 0,0,90,77,0,100,53,0,100,137,0,100,138,0,132,1, - 0,90,78,0,100,139,0,100,140,0,132,0,0,90,79,0, - 100,141,0,90,80,0,101,80,0,100,142,0,23,90,81,0, - 100,143,0,100,144,0,132,0,0,90,82,0,100,145,0,100, - 146,0,132,0,0,90,83,0,100,53,0,100,80,0,100,147, - 0,100,148,0,132,2,0,90,84,0,100,149,0,100,150,0, - 132,0,0,90,85,0,100,151,0,100,152,0,132,0,0,90, - 86,0,100,153,0,100,154,0,132,0,0,90,87,0,100,53, - 0,100,53,0,102,0,0,100,80,0,100,155,0,100,156,0, - 132,4,0,90,88,0,100,157,0,100,158,0,132,0,0,90, - 89,0,100,159,0,100,160,0,132,0,0,90,90,0,100,161, - 0,100,162,0,132,0,0,90,91,0,100,53,0,83,41,164, - 97,83,1,0,0,67,111,114,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,10,10,84,104,105,115,32,109,111,100,117,108,101, - 32,105,115,32,78,79,84,32,109,101,97,110,116,32,116,111, - 32,98,101,32,100,105,114,101,99,116,108,121,32,105,109,112, - 111,114,116,101,100,33,32,73,116,32,104,97,115,32,98,101, - 101,110,32,100,101,115,105,103,110,101,100,32,115,117,99,104, - 10,116,104,97,116,32,105,116,32,99,97,110,32,98,101,32, - 98,111,111,116,115,116,114,97,112,112,101,100,32,105,110,116, - 111,32,80,121,116,104,111,110,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,32,65,115,10,115,117,99, - 104,32,105,116,32,114,101,113,117,105,114,101,115,32,116,104, - 101,32,105,110,106,101,99,116,105,111,110,32,111,102,32,115, - 112,101,99,105,102,105,99,32,109,111,100,117,108,101,115,32, - 97,110,100,32,97,116,116,114,105,98,117,116,101,115,32,105, - 110,32,111,114,100,101,114,32,116,111,10,119,111,114,107,46, - 32,79,110,101,32,115,104,111,117,108,100,32,117,115,101,32, - 105,109,112,111,114,116,108,105,98,32,97,115,32,116,104,101, - 32,112,117,98,108,105,99,45,102,97,99,105,110,103,32,118, - 101,114,115,105,111,110,32,111,102,32,116,104,105,115,32,109, - 111,100,117,108,101,46,10,10,218,3,119,105,110,218,6,99, - 121,103,119,105,110,218,6,100,97,114,119,105,110,99,0,0, - 0,0,0,0,0,0,1,0,0,0,2,0,0,0,67,0, - 0,0,115,49,0,0,0,116,0,0,106,1,0,106,2,0, - 116,3,0,131,1,0,114,33,0,100,1,0,100,2,0,132, - 0,0,125,0,0,110,12,0,100,3,0,100,2,0,132,0, - 0,125,0,0,124,0,0,83,41,4,78,99,0,0,0,0, - 0,0,0,0,0,0,0,0,2,0,0,0,83,0,0,0, - 115,13,0,0,0,100,1,0,116,0,0,106,1,0,107,6, - 0,83,41,2,122,53,84,114,117,101,32,105,102,32,102,105, - 108,101,110,97,109,101,115,32,109,117,115,116,32,98,101,32, - 99,104,101,99,107,101,100,32,99,97,115,101,45,105,110,115, - 101,110,115,105,116,105,118,101,108,121,46,115,12,0,0,0, - 80,89,84,72,79,78,67,65,83,69,79,75,41,2,218,3, - 95,111,115,90,7,101,110,118,105,114,111,110,169,0,114,4, - 0,0,0,114,4,0,0,0,250,29,60,102,114,111,122,101, - 110,32,105,109,112,111,114,116,108,105,98,46,95,98,111,111, - 116,115,116,114,97,112,62,218,11,95,114,101,108,97,120,95, - 99,97,115,101,30,0,0,0,115,2,0,0,0,0,2,122, - 37,95,109,97,107,101,95,114,101,108,97,120,95,99,97,115, - 101,46,60,108,111,99,97,108,115,62,46,95,114,101,108,97, - 120,95,99,97,115,101,99,0,0,0,0,0,0,0,0,0, - 0,0,0,1,0,0,0,83,0,0,0,115,4,0,0,0, - 100,1,0,83,41,2,122,53,84,114,117,101,32,105,102,32, - 102,105,108,101,110,97,109,101,115,32,109,117,115,116,32,98, - 101,32,99,104,101,99,107,101,100,32,99,97,115,101,45,105, - 110,115,101,110,115,105,116,105,118,101,108,121,46,70,114,4, - 0,0,0,114,4,0,0,0,114,4,0,0,0,114,4,0, - 0,0,114,5,0,0,0,114,6,0,0,0,34,0,0,0, - 115,2,0,0,0,0,2,41,4,218,3,115,121,115,218,8, - 112,108,97,116,102,111,114,109,218,10,115,116,97,114,116,115, - 119,105,116,104,218,27,95,67,65,83,69,95,73,78,83,69, - 78,83,73,84,73,86,69,95,80,76,65,84,70,79,82,77, - 83,41,1,114,6,0,0,0,114,4,0,0,0,114,4,0, - 0,0,114,5,0,0,0,218,16,95,109,97,107,101,95,114, - 101,108,97,120,95,99,97,115,101,28,0,0,0,115,8,0, - 0,0,0,1,18,1,15,4,12,3,114,11,0,0,0,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,131, - 1,0,100,1,0,64,106,1,0,100,2,0,100,3,0,131, - 2,0,83,41,4,122,42,67,111,110,118,101,114,116,32,97, - 32,51,50,45,98,105,116,32,105,110,116,101,103,101,114,32, - 116,111,32,108,105,116,116,108,101,45,101,110,100,105,97,110, - 46,108,3,0,0,0,255,127,255,127,3,0,233,4,0,0, - 0,218,6,108,105,116,116,108,101,41,2,218,3,105,110,116, - 218,8,116,111,95,98,121,116,101,115,41,1,218,1,120,114, - 4,0,0,0,114,4,0,0,0,114,5,0,0,0,218,7, - 95,119,95,108,111,110,103,40,0,0,0,115,2,0,0,0, - 0,2,114,17,0,0,0,99,1,0,0,0,0,0,0,0, - 1,0,0,0,3,0,0,0,67,0,0,0,115,16,0,0, - 0,116,0,0,106,1,0,124,0,0,100,1,0,131,2,0, - 83,41,2,122,47,67,111,110,118,101,114,116,32,52,32,98, - 121,116,101,115,32,105,110,32,108,105,116,116,108,101,45,101, - 110,100,105,97,110,32,116,111,32,97,110,32,105,110,116,101, - 103,101,114,46,114,13,0,0,0,41,2,114,14,0,0,0, - 218,10,102,114,111,109,95,98,121,116,101,115,41,1,90,9, - 105,110,116,95,98,121,116,101,115,114,4,0,0,0,114,4, - 0,0,0,114,5,0,0,0,218,7,95,114,95,108,111,110, - 103,45,0,0,0,115,2,0,0,0,0,2,114,19,0,0, - 0,99,0,0,0,0,0,0,0,0,1,0,0,0,3,0, - 0,0,71,0,0,0,115,26,0,0,0,116,0,0,106,1, - 0,100,1,0,100,2,0,132,0,0,124,0,0,68,131,1, - 0,131,1,0,83,41,3,122,31,82,101,112,108,97,99,101, - 109,101,110,116,32,102,111,114,32,111,115,46,112,97,116,104, - 46,106,111,105,110,40,41,46,99,1,0,0,0,0,0,0, - 0,2,0,0,0,4,0,0,0,83,0,0,0,115,37,0, - 0,0,103,0,0,124,0,0,93,27,0,125,1,0,124,1, - 0,114,6,0,124,1,0,106,0,0,116,1,0,131,1,0, - 145,2,0,113,6,0,83,114,4,0,0,0,41,2,218,6, - 114,115,116,114,105,112,218,15,112,97,116,104,95,115,101,112, - 97,114,97,116,111,114,115,41,2,218,2,46,48,218,4,112, - 97,114,116,114,4,0,0,0,114,4,0,0,0,114,5,0, - 0,0,250,10,60,108,105,115,116,99,111,109,112,62,52,0, - 0,0,115,2,0,0,0,9,1,122,30,95,112,97,116,104, - 95,106,111,105,110,46,60,108,111,99,97,108,115,62,46,60, - 108,105,115,116,99,111,109,112,62,41,2,218,8,112,97,116, - 104,95,115,101,112,218,4,106,111,105,110,41,1,218,10,112, - 97,116,104,95,112,97,114,116,115,114,4,0,0,0,114,4, - 0,0,0,114,5,0,0,0,218,10,95,112,97,116,104,95, - 106,111,105,110,50,0,0,0,115,4,0,0,0,0,2,15, - 1,114,28,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,134,0,0,0, - 116,0,0,116,1,0,131,1,0,100,1,0,107,2,0,114, - 52,0,124,0,0,106,2,0,116,3,0,131,1,0,92,3, - 0,125,1,0,125,2,0,125,3,0,124,1,0,124,3,0, - 102,2,0,83,120,69,0,116,4,0,124,0,0,131,1,0, - 68,93,55,0,125,4,0,124,4,0,116,1,0,107,6,0, - 114,65,0,124,0,0,106,5,0,124,4,0,100,2,0,100, - 1,0,131,1,1,92,2,0,125,1,0,125,3,0,124,1, - 0,124,3,0,102,2,0,83,113,65,0,87,100,3,0,124, - 0,0,102,2,0,83,41,4,122,32,82,101,112,108,97,99, - 101,109,101,110,116,32,102,111,114,32,111,115,46,112,97,116, - 104,46,115,112,108,105,116,40,41,46,233,1,0,0,0,90, - 8,109,97,120,115,112,108,105,116,218,0,41,6,218,3,108, - 101,110,114,21,0,0,0,218,10,114,112,97,114,116,105,116, - 105,111,110,114,25,0,0,0,218,8,114,101,118,101,114,115, - 101,100,218,6,114,115,112,108,105,116,41,5,218,4,112,97, - 116,104,90,5,102,114,111,110,116,218,1,95,218,4,116,97, - 105,108,114,16,0,0,0,114,4,0,0,0,114,4,0,0, - 0,114,5,0,0,0,218,11,95,112,97,116,104,95,115,112, - 108,105,116,56,0,0,0,115,16,0,0,0,0,2,18,1, - 24,1,10,1,19,1,12,1,27,1,14,1,114,38,0,0, - 0,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,116,0,0,106,1, - 0,124,0,0,131,1,0,83,41,1,122,126,83,116,97,116, - 32,116,104,101,32,112,97,116,104,46,10,10,32,32,32,32, - 77,97,100,101,32,97,32,115,101,112,97,114,97,116,101,32, - 102,117,110,99,116,105,111,110,32,116,111,32,109,97,107,101, - 32,105,116,32,101,97,115,105,101,114,32,116,111,32,111,118, - 101,114,114,105,100,101,32,105,110,32,101,120,112,101,114,105, - 109,101,110,116,115,10,32,32,32,32,40,101,46,103,46,32, - 99,97,99,104,101,32,115,116,97,116,32,114,101,115,117,108, - 116,115,41,46,10,10,32,32,32,32,41,2,114,3,0,0, - 0,90,4,115,116,97,116,41,1,114,35,0,0,0,114,4, - 0,0,0,114,4,0,0,0,114,5,0,0,0,218,10,95, - 112,97,116,104,95,115,116,97,116,68,0,0,0,115,2,0, - 0,0,0,7,114,39,0,0,0,99,2,0,0,0,0,0, - 0,0,3,0,0,0,11,0,0,0,67,0,0,0,115,58, - 0,0,0,121,16,0,116,0,0,124,0,0,131,1,0,125, - 2,0,87,110,22,0,4,116,1,0,107,10,0,114,40,0, - 1,1,1,100,1,0,83,89,110,1,0,88,124,2,0,106, - 2,0,100,2,0,64,124,1,0,107,2,0,83,41,3,122, - 49,84,101,115,116,32,119,104,101,116,104,101,114,32,116,104, - 101,32,112,97,116,104,32,105,115,32,116,104,101,32,115,112, - 101,99,105,102,105,101,100,32,109,111,100,101,32,116,121,112, - 101,46,70,105,0,240,0,0,41,3,114,39,0,0,0,218, - 7,79,83,69,114,114,111,114,218,7,115,116,95,109,111,100, - 101,41,3,114,35,0,0,0,218,4,109,111,100,101,90,9, - 115,116,97,116,95,105,110,102,111,114,4,0,0,0,114,4, - 0,0,0,114,5,0,0,0,218,18,95,112,97,116,104,95, - 105,115,95,109,111,100,101,95,116,121,112,101,78,0,0,0, - 115,10,0,0,0,0,2,3,1,16,1,13,1,9,1,114, - 43,0,0,0,99,1,0,0,0,0,0,0,0,1,0,0, - 0,3,0,0,0,67,0,0,0,115,13,0,0,0,116,0, - 0,124,0,0,100,1,0,131,2,0,83,41,2,122,31,82, - 101,112,108,97,99,101,109,101,110,116,32,102,111,114,32,111, - 115,46,112,97,116,104,46,105,115,102,105,108,101,46,105,0, - 128,0,0,41,1,114,43,0,0,0,41,1,114,35,0,0, - 0,114,4,0,0,0,114,4,0,0,0,114,5,0,0,0, - 218,12,95,112,97,116,104,95,105,115,102,105,108,101,87,0, - 0,0,115,2,0,0,0,0,2,114,44,0,0,0,99,1, - 0,0,0,0,0,0,0,1,0,0,0,3,0,0,0,67, - 0,0,0,115,34,0,0,0,124,0,0,115,21,0,116,0, - 0,106,1,0,131,0,0,125,0,0,110,0,0,116,2,0, - 124,0,0,100,1,0,131,2,0,83,41,2,122,30,82,101, - 112,108,97,99,101,109,101,110,116,32,102,111,114,32,111,115, - 46,112,97,116,104,46,105,115,100,105,114,46,105,0,64,0, - 0,41,3,114,3,0,0,0,218,6,103,101,116,99,119,100, - 114,43,0,0,0,41,1,114,35,0,0,0,114,4,0,0, - 0,114,4,0,0,0,114,5,0,0,0,218,11,95,112,97, - 116,104,95,105,115,100,105,114,92,0,0,0,115,6,0,0, - 0,0,2,6,1,15,1,114,46,0,0,0,105,182,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,192,0,0,0,100,1,0,106,0, - 0,124,0,0,116,1,0,124,0,0,131,1,0,131,2,0, - 125,3,0,116,2,0,106,3,0,124,3,0,116,2,0,106, - 4,0,116,2,0,106,5,0,66,116,2,0,106,6,0,66, - 124,2,0,100,2,0,64,131,3,0,125,4,0,121,60,0, - 116,7,0,106,8,0,124,4,0,100,3,0,131,2,0,143, - 20,0,125,5,0,124,5,0,106,9,0,124,1,0,131,1, - 0,1,87,100,4,0,81,88,116,2,0,106,10,0,124,3, - 0,124,0,0,131,2,0,1,87,110,59,0,4,116,11,0, - 107,10,0,114,187,0,1,1,1,121,17,0,116,2,0,106, - 12,0,124,3,0,131,1,0,1,87,110,18,0,4,116,11, - 0,107,10,0,114,179,0,1,1,1,89,110,1,0,88,130, - 0,0,89,110,1,0,88,100,4,0,83,41,5,122,162,66, - 101,115,116,45,101,102,102,111,114,116,32,102,117,110,99,116, - 105,111,110,32,116,111,32,119,114,105,116,101,32,100,97,116, - 97,32,116,111,32,97,32,112,97,116,104,32,97,116,111,109, - 105,99,97,108,108,121,46,10,32,32,32,32,66,101,32,112, - 114,101,112,97,114,101,100,32,116,111,32,104,97,110,100,108, - 101,32,97,32,70,105,108,101,69,120,105,115,116,115,69,114, - 114,111,114,32,105,102,32,99,111,110,99,117,114,114,101,110, - 116,32,119,114,105,116,105,110,103,32,111,102,32,116,104,101, - 10,32,32,32,32,116,101,109,112,111,114,97,114,121,32,102, - 105,108,101,32,105,115,32,97,116,116,101,109,112,116,101,100, - 46,122,5,123,125,46,123,125,105,182,1,0,0,90,2,119, - 98,78,41,13,218,6,102,111,114,109,97,116,218,2,105,100, - 114,3,0,0,0,90,4,111,112,101,110,90,6,79,95,69, - 88,67,76,90,7,79,95,67,82,69,65,84,90,8,79,95, - 87,82,79,78,76,89,218,3,95,105,111,218,6,70,105,108, - 101,73,79,218,5,119,114,105,116,101,218,7,114,101,112,108, - 97,99,101,114,40,0,0,0,90,6,117,110,108,105,110,107, - 41,6,114,35,0,0,0,218,4,100,97,116,97,114,42,0, - 0,0,90,8,112,97,116,104,95,116,109,112,90,2,102,100, - 218,4,102,105,108,101,114,4,0,0,0,114,4,0,0,0, - 114,5,0,0,0,218,13,95,119,114,105,116,101,95,97,116, - 111,109,105,99,99,0,0,0,115,26,0,0,0,0,5,24, - 1,9,1,33,1,3,3,21,1,19,1,20,1,13,1,3, - 1,17,1,13,1,5,1,114,55,0,0,0,99,2,0,0, - 0,0,0,0,0,3,0,0,0,7,0,0,0,67,0,0, - 0,115,95,0,0,0,120,69,0,100,1,0,100,2,0,100, - 3,0,100,4,0,103,4,0,68,93,49,0,125,2,0,116, - 0,0,124,1,0,124,2,0,131,2,0,114,19,0,116,1, - 0,124,0,0,124,2,0,116,2,0,124,1,0,124,2,0, - 131,2,0,131,3,0,1,113,19,0,113,19,0,87,124,0, - 0,106,3,0,106,4,0,124,1,0,106,3,0,131,1,0, - 1,100,5,0,83,41,6,122,47,83,105,109,112,108,101,32, - 115,117,98,115,116,105,116,117,116,101,32,102,111,114,32,102, - 117,110,99,116,111,111,108,115,46,117,112,100,97,116,101,95, - 119,114,97,112,112,101,114,46,218,10,95,95,109,111,100,117, - 108,101,95,95,218,8,95,95,110,97,109,101,95,95,218,12, - 95,95,113,117,97,108,110,97,109,101,95,95,218,7,95,95, - 100,111,99,95,95,78,41,5,218,7,104,97,115,97,116,116, - 114,218,7,115,101,116,97,116,116,114,218,7,103,101,116,97, - 116,116,114,218,8,95,95,100,105,99,116,95,95,218,6,117, - 112,100,97,116,101,41,3,90,3,110,101,119,90,3,111,108, - 100,114,52,0,0,0,114,4,0,0,0,114,4,0,0,0, - 114,5,0,0,0,218,5,95,119,114,97,112,121,0,0,0, - 115,8,0,0,0,0,2,25,1,15,1,32,1,114,65,0, - 0,0,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,116, - 1,0,131,1,0,124,0,0,131,1,0,83,41,1,78,41, - 2,218,4,116,121,112,101,114,7,0,0,0,41,1,218,4, - 110,97,109,101,114,4,0,0,0,114,4,0,0,0,114,5, - 0,0,0,218,11,95,110,101,119,95,109,111,100,117,108,101, - 129,0,0,0,115,2,0,0,0,0,1,114,68,0,0,0, - 99,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0, - 0,64,0,0,0,115,58,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,83,41,9,218,13,95,77,97,110,97,103,101,82, - 101,108,111,97,100,122,63,77,97,110,97,103,101,115,32,116, - 104,101,32,112,111,115,115,105,98,108,101,32,99,108,101,97, - 110,45,117,112,32,111,102,32,115,121,115,46,109,111,100,117, - 108,101,115,32,102,111,114,32,108,111,97,100,95,109,111,100, - 117,108,101,40,41,46,99,2,0,0,0,0,0,0,0,2, - 0,0,0,2,0,0,0,67,0,0,0,115,13,0,0,0, - 124,1,0,124,0,0,95,0,0,100,0,0,83,41,1,78, - 41,1,218,5,95,110,97,109,101,41,2,218,4,115,101,108, - 102,114,67,0,0,0,114,4,0,0,0,114,4,0,0,0, - 114,5,0,0,0,218,8,95,95,105,110,105,116,95,95,141, - 0,0,0,115,2,0,0,0,0,1,122,22,95,77,97,110, - 97,103,101,82,101,108,111,97,100,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,25,0,0,0,124,0,0,106, - 0,0,116,1,0,106,2,0,107,6,0,124,0,0,95,3, - 0,100,0,0,83,41,1,78,41,4,114,70,0,0,0,114, - 7,0,0,0,218,7,109,111,100,117,108,101,115,218,10,95, - 105,115,95,114,101,108,111,97,100,41,1,114,71,0,0,0, - 114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,218, - 9,95,95,101,110,116,101,114,95,95,144,0,0,0,115,2, - 0,0,0,0,1,122,23,95,77,97,110,97,103,101,82,101, - 108,111,97,100,46,95,95,101,110,116,101,114,95,95,99,1, - 0,0,0,0,0,0,0,2,0,0,0,11,0,0,0,71, - 0,0,0,115,80,0,0,0,116,0,0,100,1,0,100,2, - 0,132,0,0,124,1,0,68,131,1,0,131,1,0,114,76, - 0,124,0,0,106,1,0,12,114,76,0,121,17,0,116,2, - 0,106,3,0,124,0,0,106,4,0,61,87,113,76,0,4, - 116,5,0,107,10,0,114,72,0,1,1,1,89,113,76,0, - 88,110,0,0,100,0,0,83,41,3,78,99,1,0,0,0, - 0,0,0,0,2,0,0,0,3,0,0,0,115,0,0,0, - 115,27,0,0,0,124,0,0,93,17,0,125,1,0,124,1, - 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,218, - 3,97,114,103,114,4,0,0,0,114,4,0,0,0,114,5, - 0,0,0,250,9,60,103,101,110,101,120,112,114,62,148,0, - 0,0,115,2,0,0,0,6,0,122,41,95,77,97,110,97, - 103,101,82,101,108,111,97,100,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,114,62,41,6,218,3,97,110,121,114,74,0,0,0, - 114,7,0,0,0,114,73,0,0,0,114,70,0,0,0,218, - 8,75,101,121,69,114,114,111,114,41,2,114,71,0,0,0, - 218,4,97,114,103,115,114,4,0,0,0,114,4,0,0,0, - 114,5,0,0,0,218,8,95,95,101,120,105,116,95,95,147, - 0,0,0,115,10,0,0,0,0,1,35,1,3,1,17,1, - 13,1,122,22,95,77,97,110,97,103,101,82,101,108,111,97, - 100,46,95,95,101,120,105,116,95,95,78,41,7,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,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,69,0,0,0,137,0,0,0,115,8,0, - 0,0,12,2,6,2,12,3,12,3,114,69,0,0,0,99, - 0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0, - 64,0,0,0,115,16,0,0,0,101,0,0,90,1,0,100, - 0,0,90,2,0,100,1,0,83,41,2,218,14,95,68,101, - 97,100,108,111,99,107,69,114,114,111,114,78,41,3,114,57, - 0,0,0,114,56,0,0,0,114,58,0,0,0,114,4,0, - 0,0,114,4,0,0,0,114,4,0,0,0,114,5,0,0, - 0,114,82,0,0,0,162,0,0,0,115,2,0,0,0,12, - 1,114,82,0,0,0,99,0,0,0,0,0,0,0,0,0, - 0,0,0,2,0,0,0,64,0,0,0,115,82,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,83,41,13,218,11,95,77,111,100,117,108,101,76,111,99, - 107,122,169,65,32,114,101,99,117,114,115,105,118,101,32,108, - 111,99,107,32,105,109,112,108,101,109,101,110,116,97,116,105, - 111,110,32,119,104,105,99,104,32,105,115,32,97,98,108,101, - 32,116,111,32,100,101,116,101,99,116,32,100,101,97,100,108, - 111,99,107,115,10,32,32,32,32,40,101,46,103,46,32,116, - 104,114,101,97,100,32,49,32,116,114,121,105,110,103,32,116, - 111,32,116,97,107,101,32,108,111,99,107,115,32,65,32,116, - 104,101,110,32,66,44,32,97,110,100,32,116,104,114,101,97, - 100,32,50,32,116,114,121,105,110,103,32,116,111,10,32,32, - 32,32,116,97,107,101,32,108,111,99,107,115,32,66,32,116, - 104,101,110,32,65,41,46,10,32,32,32,32,99,2,0,0, - 0,0,0,0,0,2,0,0,0,2,0,0,0,67,0,0, - 0,115,70,0,0,0,116,0,0,106,1,0,131,0,0,124, - 0,0,95,2,0,116,0,0,106,1,0,131,0,0,124,0, - 0,95,3,0,124,1,0,124,0,0,95,4,0,100,0,0, - 124,0,0,95,5,0,100,1,0,124,0,0,95,6,0,100, - 1,0,124,0,0,95,7,0,100,0,0,83,41,2,78,233, - 0,0,0,0,41,8,218,7,95,116,104,114,101,97,100,90, - 13,97,108,108,111,99,97,116,101,95,108,111,99,107,218,4, - 108,111,99,107,218,6,119,97,107,101,117,112,114,67,0,0, - 0,218,5,111,119,110,101,114,218,5,99,111,117,110,116,218, - 7,119,97,105,116,101,114,115,41,2,114,71,0,0,0,114, - 67,0,0,0,114,4,0,0,0,114,4,0,0,0,114,5, - 0,0,0,114,72,0,0,0,172,0,0,0,115,12,0,0, - 0,0,1,15,1,15,1,9,1,9,1,9,1,122,20,95, - 77,111,100,117,108,101,76,111,99,107,46,95,95,105,110,105, - 116,95,95,99,1,0,0,0,0,0,0,0,4,0,0,0, - 2,0,0,0,67,0,0,0,115,88,0,0,0,116,0,0, - 106,1,0,131,0,0,125,1,0,124,0,0,106,2,0,125, - 2,0,120,60,0,116,3,0,106,4,0,124,2,0,131,1, - 0,125,3,0,124,3,0,100,0,0,107,8,0,114,55,0, - 100,1,0,83,124,3,0,106,2,0,125,2,0,124,2,0, - 124,1,0,107,2,0,114,24,0,100,2,0,83,113,24,0, - 87,100,0,0,83,41,3,78,70,84,41,5,114,85,0,0, - 0,218,9,103,101,116,95,105,100,101,110,116,114,88,0,0, - 0,218,12,95,98,108,111,99,107,105,110,103,95,111,110,218, - 3,103,101,116,41,4,114,71,0,0,0,218,2,109,101,218, - 3,116,105,100,114,86,0,0,0,114,4,0,0,0,114,4, - 0,0,0,114,5,0,0,0,218,12,104,97,115,95,100,101, - 97,100,108,111,99,107,180,0,0,0,115,18,0,0,0,0, - 2,12,1,9,1,3,1,15,1,12,1,4,1,9,1,12, - 1,122,24,95,77,111,100,117,108,101,76,111,99,107,46,104, - 97,115,95,100,101,97,100,108,111,99,107,99,1,0,0,0, - 0,0,0,0,2,0,0,0,16,0,0,0,67,0,0,0, - 115,215,0,0,0,116,0,0,106,1,0,131,0,0,125,1, - 0,124,0,0,116,2,0,124,1,0,60,122,178,0,120,171, - 0,124,0,0,106,3,0,143,130,0,1,124,0,0,106,4, - 0,100,1,0,107,2,0,115,68,0,124,0,0,106,5,0, - 124,1,0,107,2,0,114,96,0,124,1,0,124,0,0,95, - 5,0,124,0,0,4,106,4,0,100,2,0,55,2,95,4, - 0,100,3,0,83,124,0,0,106,6,0,131,0,0,114,127, - 0,116,7,0,100,4,0,124,0,0,22,131,1,0,130,1, - 0,110,0,0,124,0,0,106,8,0,106,9,0,100,5,0, - 131,1,0,114,163,0,124,0,0,4,106,10,0,100,2,0, - 55,2,95,10,0,110,0,0,87,100,6,0,81,88,124,0, - 0,106,8,0,106,9,0,131,0,0,1,124,0,0,106,8, - 0,106,11,0,131,0,0,1,113,28,0,87,87,100,6,0, - 116,2,0,124,1,0,61,88,100,6,0,83,41,7,122,185, - 10,32,32,32,32,32,32,32,32,65,99,113,117,105,114,101, - 32,116,104,101,32,109,111,100,117,108,101,32,108,111,99,107, - 46,32,32,73,102,32,97,32,112,111,116,101,110,116,105,97, - 108,32,100,101,97,100,108,111,99,107,32,105,115,32,100,101, - 116,101,99,116,101,100,44,10,32,32,32,32,32,32,32,32, - 97,32,95,68,101,97,100,108,111,99,107,69,114,114,111,114, - 32,105,115,32,114,97,105,115,101,100,46,10,32,32,32,32, - 32,32,32,32,79,116,104,101,114,119,105,115,101,44,32,116, - 104,101,32,108,111,99,107,32,105,115,32,97,108,119,97,121, - 115,32,97,99,113,117,105,114,101,100,32,97,110,100,32,84, - 114,117,101,32,105,115,32,114,101,116,117,114,110,101,100,46, - 10,32,32,32,32,32,32,32,32,114,84,0,0,0,114,29, - 0,0,0,84,122,23,100,101,97,100,108,111,99,107,32,100, - 101,116,101,99,116,101,100,32,98,121,32,37,114,70,78,41, - 12,114,85,0,0,0,114,91,0,0,0,114,92,0,0,0, - 114,86,0,0,0,114,89,0,0,0,114,88,0,0,0,114, - 96,0,0,0,114,82,0,0,0,114,87,0,0,0,218,7, - 97,99,113,117,105,114,101,114,90,0,0,0,218,7,114,101, - 108,101,97,115,101,41,2,114,71,0,0,0,114,95,0,0, - 0,114,4,0,0,0,114,4,0,0,0,114,5,0,0,0, - 114,97,0,0,0,192,0,0,0,115,32,0,0,0,0,6, - 12,1,10,1,3,1,3,1,10,1,30,1,9,1,15,1, - 4,1,12,1,19,1,18,1,24,2,13,1,21,2,122,19, - 95,77,111,100,117,108,101,76,111,99,107,46,97,99,113,117, - 105,114,101,99,1,0,0,0,0,0,0,0,2,0,0,0, - 10,0,0,0,67,0,0,0,115,165,0,0,0,116,0,0, - 106,1,0,131,0,0,125,1,0,124,0,0,106,2,0,143, - 138,0,1,124,0,0,106,3,0,124,1,0,107,3,0,114, - 52,0,116,4,0,100,1,0,131,1,0,130,1,0,110,0, - 0,124,0,0,106,5,0,100,2,0,107,4,0,115,73,0, - 116,6,0,130,1,0,124,0,0,4,106,5,0,100,3,0, - 56,2,95,5,0,124,0,0,106,5,0,100,2,0,107,2, - 0,114,155,0,100,0,0,124,0,0,95,3,0,124,0,0, - 106,7,0,114,155,0,124,0,0,4,106,7,0,100,3,0, - 56,2,95,7,0,124,0,0,106,8,0,106,9,0,131,0, - 0,1,113,155,0,110,0,0,87,100,0,0,81,88,100,0, - 0,83,41,4,78,122,31,99,97,110,110,111,116,32,114,101, - 108,101,97,115,101,32,117,110,45,97,99,113,117,105,114,101, - 100,32,108,111,99,107,114,84,0,0,0,114,29,0,0,0, - 41,10,114,85,0,0,0,114,91,0,0,0,114,86,0,0, - 0,114,88,0,0,0,218,12,82,117,110,116,105,109,101,69, - 114,114,111,114,114,89,0,0,0,218,14,65,115,115,101,114, - 116,105,111,110,69,114,114,111,114,114,90,0,0,0,114,87, - 0,0,0,114,98,0,0,0,41,2,114,71,0,0,0,114, - 95,0,0,0,114,4,0,0,0,114,4,0,0,0,114,5, - 0,0,0,114,98,0,0,0,217,0,0,0,115,22,0,0, - 0,0,1,12,1,10,1,15,1,15,1,21,1,15,1,15, - 1,9,1,9,1,15,1,122,19,95,77,111,100,117,108,101, - 76,111,99,107,46,114,101,108,101,97,115,101,99,1,0,0, - 0,0,0,0,0,1,0,0,0,4,0,0,0,67,0,0, - 0,115,25,0,0,0,100,1,0,106,0,0,124,0,0,106, - 1,0,116,2,0,124,0,0,131,1,0,131,2,0,83,41, - 2,78,122,23,95,77,111,100,117,108,101,76,111,99,107,40, - 123,33,114,125,41,32,97,116,32,123,125,41,3,114,47,0, - 0,0,114,67,0,0,0,114,48,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,114,101,112,114,95,95,230,0,0,0, - 115,2,0,0,0,0,1,122,20,95,77,111,100,117,108,101, - 76,111,99,107,46,95,95,114,101,112,114,95,95,78,41,9, - 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,96,0,0,0,114,97, - 0,0,0,114,98,0,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,83,0,0,0,166,0,0,0,115,12,0,0,0,12, - 4,6,2,12,8,12,12,12,25,12,13,114,83,0,0,0, - 99,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0, - 0,64,0,0,0,115,70,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,83, - 41,11,218,16,95,68,117,109,109,121,77,111,100,117,108,101, - 76,111,99,107,122,86,65,32,115,105,109,112,108,101,32,95, - 77,111,100,117,108,101,76,111,99,107,32,101,113,117,105,118, - 97,108,101,110,116,32,102,111,114,32,80,121,116,104,111,110, - 32,98,117,105,108,100,115,32,119,105,116,104,111,117,116,10, - 32,32,32,32,109,117,108,116,105,45,116,104,114,101,97,100, - 105,110,103,32,115,117,112,112,111,114,116,46,99,2,0,0, - 0,0,0,0,0,2,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,100, - 1,0,124,0,0,95,1,0,100,0,0,83,41,2,78,114, - 84,0,0,0,41,2,114,67,0,0,0,114,89,0,0,0, - 41,2,114,71,0,0,0,114,67,0,0,0,114,4,0,0, - 0,114,4,0,0,0,114,5,0,0,0,114,72,0,0,0, - 238,0,0,0,115,4,0,0,0,0,1,9,1,122,25,95, - 68,117,109,109,121,77,111,100,117,108,101,76,111,99,107,46, - 95,95,105,110,105,116,95,95,99,1,0,0,0,0,0,0, - 0,1,0,0,0,3,0,0,0,67,0,0,0,115,19,0, - 0,0,124,0,0,4,106,0,0,100,1,0,55,2,95,0, - 0,100,2,0,83,41,3,78,114,29,0,0,0,84,41,1, - 114,89,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,97,0,0,0, - 242,0,0,0,115,4,0,0,0,0,1,15,1,122,24,95, - 68,117,109,109,121,77,111,100,117,108,101,76,111,99,107,46, - 97,99,113,117,105,114,101,99,1,0,0,0,0,0,0,0, - 1,0,0,0,3,0,0,0,67,0,0,0,115,49,0,0, - 0,124,0,0,106,0,0,100,1,0,107,2,0,114,30,0, - 116,1,0,100,2,0,131,1,0,130,1,0,110,0,0,124, - 0,0,4,106,0,0,100,3,0,56,2,95,0,0,100,0, - 0,83,41,4,78,114,84,0,0,0,122,31,99,97,110,110, - 111,116,32,114,101,108,101,97,115,101,32,117,110,45,97,99, - 113,117,105,114,101,100,32,108,111,99,107,114,29,0,0,0, - 41,2,114,89,0,0,0,114,99,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,98,0,0,0,246,0,0,0,115,6,0,0,0, - 0,1,15,1,15,1,122,24,95,68,117,109,109,121,77,111, - 100,117,108,101,76,111,99,107,46,114,101,108,101,97,115,101, - 99,1,0,0,0,0,0,0,0,1,0,0,0,4,0,0, - 0,67,0,0,0,115,25,0,0,0,100,1,0,106,0,0, - 124,0,0,106,1,0,116,2,0,124,0,0,131,1,0,131, - 2,0,83,41,2,78,122,28,95,68,117,109,109,121,77,111, + 99,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0, + 0,64,0,0,0,115,169,2,0,0,100,0,0,90,0,0, + 100,1,0,97,1,0,100,2,0,100,3,0,132,0,0,90, + 2,0,100,4,0,100,5,0,132,0,0,90,3,0,71,100, + 6,0,100,7,0,132,0,0,100,7,0,131,2,0,90,4, + 0,105,0,0,90,5,0,105,0,0,90,6,0,71,100,8, + 0,100,9,0,132,0,0,100,9,0,101,7,0,131,3,0, + 90,8,0,71,100,10,0,100,11,0,132,0,0,100,11,0, + 131,2,0,90,9,0,71,100,12,0,100,13,0,132,0,0, + 100,13,0,131,2,0,90,10,0,71,100,14,0,100,15,0, + 132,0,0,100,15,0,131,2,0,90,11,0,100,16,0,100, + 17,0,132,0,0,90,12,0,100,18,0,100,19,0,132,0, + 0,90,13,0,100,20,0,100,21,0,132,0,0,90,14,0, + 100,22,0,100,23,0,100,24,0,100,25,0,132,0,1,90, + 15,0,100,26,0,100,27,0,132,0,0,90,16,0,100,28, + 0,100,29,0,132,0,0,90,17,0,100,30,0,100,31,0, + 132,0,0,90,18,0,100,32,0,100,33,0,132,0,0,90, + 19,0,71,100,34,0,100,35,0,132,0,0,100,35,0,131, + 2,0,90,20,0,71,100,36,0,100,37,0,132,0,0,100, + 37,0,131,2,0,90,21,0,100,38,0,100,1,0,100,39, + 0,100,1,0,100,40,0,100,41,0,132,0,2,90,22,0, + 101,23,0,131,0,0,90,24,0,100,1,0,100,1,0,100, + 42,0,100,43,0,132,2,0,90,25,0,100,44,0,100,45, + 0,100,46,0,100,47,0,132,0,1,90,26,0,100,48,0, + 100,49,0,132,0,0,90,27,0,100,50,0,100,51,0,132, + 0,0,90,28,0,100,52,0,100,53,0,132,0,0,90,29, + 0,100,54,0,100,55,0,132,0,0,90,30,0,100,56,0, + 100,57,0,132,0,0,90,31,0,100,58,0,100,59,0,132, + 0,0,90,32,0,71,100,60,0,100,61,0,132,0,0,100, + 61,0,131,2,0,90,33,0,71,100,62,0,100,63,0,132, + 0,0,100,63,0,131,2,0,90,34,0,71,100,64,0,100, + 65,0,132,0,0,100,65,0,131,2,0,90,35,0,100,66, + 0,100,67,0,132,0,0,90,36,0,100,68,0,100,69,0, + 132,0,0,90,37,0,100,1,0,100,70,0,100,71,0,132, + 1,0,90,38,0,100,72,0,100,73,0,132,0,0,90,39, + 0,100,74,0,90,40,0,101,40,0,100,75,0,23,90,41, + 0,100,76,0,100,77,0,132,0,0,90,42,0,100,78,0, + 100,79,0,132,0,0,90,43,0,100,1,0,100,80,0,100, + 81,0,100,82,0,132,2,0,90,44,0,100,83,0,100,84, + 0,132,0,0,90,45,0,100,85,0,100,86,0,132,0,0, + 90,46,0,100,1,0,100,1,0,102,0,0,100,80,0,100, + 87,0,100,88,0,132,4,0,90,47,0,100,89,0,100,90, + 0,132,0,0,90,48,0,100,91,0,100,92,0,132,0,0, + 90,49,0,100,93,0,100,94,0,132,0,0,90,50,0,100, + 1,0,83,41,95,97,83,1,0,0,67,111,114,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,10,10,84,104,105,115,32,109, + 111,100,117,108,101,32,105,115,32,78,79,84,32,109,101,97, + 110,116,32,116,111,32,98,101,32,100,105,114,101,99,116,108, + 121,32,105,109,112,111,114,116,101,100,33,32,73,116,32,104, + 97,115,32,98,101,101,110,32,100,101,115,105,103,110,101,100, + 32,115,117,99,104,10,116,104,97,116,32,105,116,32,99,97, + 110,32,98,101,32,98,111,111,116,115,116,114,97,112,112,101, + 100,32,105,110,116,111,32,80,121,116,104,111,110,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,32,65, + 115,10,115,117,99,104,32,105,116,32,114,101,113,117,105,114, + 101,115,32,116,104,101,32,105,110,106,101,99,116,105,111,110, + 32,111,102,32,115,112,101,99,105,102,105,99,32,109,111,100, + 117,108,101,115,32,97,110,100,32,97,116,116,114,105,98,117, + 116,101,115,32,105,110,32,111,114,100,101,114,32,116,111,10, + 119,111,114,107,46,32,79,110,101,32,115,104,111,117,108,100, + 32,117,115,101,32,105,109,112,111,114,116,108,105,98,32,97, + 115,32,116,104,101,32,112,117,98,108,105,99,45,102,97,99, + 105,110,103,32,118,101,114,115,105,111,110,32,111,102,32,116, + 104,105,115,32,109,111,100,117,108,101,46,10,10,78,99,2, + 0,0,0,0,0,0,0,3,0,0,0,7,0,0,0,67, + 0,0,0,115,92,0,0,0,120,66,0,100,1,0,100,2, + 0,100,3,0,100,4,0,103,4,0,68,93,46,0,125,2, + 0,116,0,0,124,1,0,124,2,0,131,2,0,114,19,0, + 116,1,0,124,0,0,124,2,0,116,2,0,124,1,0,124, + 2,0,131,2,0,131,3,0,1,113,19,0,87,124,0,0, + 106,3,0,106,4,0,124,1,0,106,3,0,131,1,0,1, + 100,5,0,83,41,6,122,47,83,105,109,112,108,101,32,115, + 117,98,115,116,105,116,117,116,101,32,102,111,114,32,102,117, + 110,99,116,111,111,108,115,46,117,112,100,97,116,101,95,119, + 114,97,112,112,101,114,46,218,10,95,95,109,111,100,117,108, + 101,95,95,218,8,95,95,110,97,109,101,95,95,218,12,95, + 95,113,117,97,108,110,97,109,101,95,95,218,7,95,95,100, + 111,99,95,95,78,41,5,218,7,104,97,115,97,116,116,114, + 218,7,115,101,116,97,116,116,114,218,7,103,101,116,97,116, + 116,114,218,8,95,95,100,105,99,116,95,95,218,6,117,112, + 100,97,116,101,41,3,90,3,110,101,119,90,3,111,108,100, + 218,7,114,101,112,108,97,99,101,169,0,114,10,0,0,0, + 250,29,60,102,114,111,122,101,110,32,105,109,112,111,114,116, + 108,105,98,46,95,98,111,111,116,115,116,114,97,112,62,218, + 5,95,119,114,97,112,27,0,0,0,115,8,0,0,0,0, + 2,25,1,15,1,29,1,114,12,0,0,0,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,116,1,0,131,1,0,124, + 0,0,131,1,0,83,41,1,78,41,2,218,4,116,121,112, + 101,218,3,115,121,115,41,1,218,4,110,97,109,101,114,10, + 0,0,0,114,10,0,0,0,114,11,0,0,0,218,11,95, + 110,101,119,95,109,111,100,117,108,101,35,0,0,0,115,2, + 0,0,0,0,1,114,16,0,0,0,99,0,0,0,0,0, + 0,0,0,0,0,0,0,2,0,0,0,64,0,0,0,115, + 58,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,83,41,9, + 218,13,95,77,97,110,97,103,101,82,101,108,111,97,100,122, + 63,77,97,110,97,103,101,115,32,116,104,101,32,112,111,115, + 115,105,98,108,101,32,99,108,101,97,110,45,117,112,32,111, + 102,32,115,121,115,46,109,111,100,117,108,101,115,32,102,111, + 114,32,108,111,97,100,95,109,111,100,117,108,101,40,41,46, + 99,2,0,0,0,0,0,0,0,2,0,0,0,2,0,0, + 0,67,0,0,0,115,13,0,0,0,124,1,0,124,0,0, + 95,0,0,100,0,0,83,41,1,78,41,1,218,5,95,110, + 97,109,101,41,2,218,4,115,101,108,102,114,15,0,0,0, + 114,10,0,0,0,114,10,0,0,0,114,11,0,0,0,218, + 8,95,95,105,110,105,116,95,95,43,0,0,0,115,2,0, + 0,0,0,1,122,22,95,77,97,110,97,103,101,82,101,108, + 111,97,100,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,25,0,0,0,124,0,0,106,0,0,116,1,0,106, + 2,0,107,6,0,124,0,0,95,3,0,100,0,0,83,41, + 1,78,41,4,114,18,0,0,0,114,14,0,0,0,218,7, + 109,111,100,117,108,101,115,218,10,95,105,115,95,114,101,108, + 111,97,100,41,1,114,19,0,0,0,114,10,0,0,0,114, + 10,0,0,0,114,11,0,0,0,218,9,95,95,101,110,116, + 101,114,95,95,46,0,0,0,115,2,0,0,0,0,1,122, + 23,95,77,97,110,97,103,101,82,101,108,111,97,100,46,95, + 95,101,110,116,101,114,95,95,99,1,0,0,0,0,0,0, + 0,2,0,0,0,11,0,0,0,71,0,0,0,115,77,0, + 0,0,116,0,0,100,1,0,100,2,0,132,0,0,124,1, + 0,68,131,1,0,131,1,0,114,73,0,124,0,0,106,1, + 0,12,114,73,0,121,17,0,116,2,0,106,3,0,124,0, + 0,106,4,0,61,87,110,18,0,4,116,5,0,107,10,0, + 114,72,0,1,1,1,89,110,1,0,88,100,0,0,83,41, + 3,78,99,1,0,0,0,0,0,0,0,2,0,0,0,3, + 0,0,0,115,0,0,0,115,27,0,0,0,124,0,0,93, + 17,0,125,1,0,124,1,0,100,0,0,107,9,0,86,1, + 113,3,0,100,0,0,83,41,1,78,114,10,0,0,0,41, + 2,218,2,46,48,218,3,97,114,103,114,10,0,0,0,114, + 10,0,0,0,114,11,0,0,0,250,9,60,103,101,110,101, + 120,112,114,62,50,0,0,0,115,2,0,0,0,6,0,122, + 41,95,77,97,110,97,103,101,82,101,108,111,97,100,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,114,62,41,6,218,3,97,110, + 121,114,22,0,0,0,114,14,0,0,0,114,21,0,0,0, + 114,18,0,0,0,218,8,75,101,121,69,114,114,111,114,41, + 2,114,19,0,0,0,218,4,97,114,103,115,114,10,0,0, + 0,114,10,0,0,0,114,11,0,0,0,218,8,95,95,101, + 120,105,116,95,95,49,0,0,0,115,10,0,0,0,0,1, + 35,1,3,1,17,1,13,1,122,22,95,77,97,110,97,103, + 101,82,101,108,111,97,100,46,95,95,101,120,105,116,95,95, + 78,41,7,114,1,0,0,0,114,0,0,0,0,114,2,0, + 0,0,114,3,0,0,0,114,20,0,0,0,114,23,0,0, + 0,114,30,0,0,0,114,10,0,0,0,114,10,0,0,0, + 114,10,0,0,0,114,11,0,0,0,114,17,0,0,0,39, + 0,0,0,115,8,0,0,0,12,2,6,2,12,3,12,3, + 114,17,0,0,0,99,0,0,0,0,0,0,0,0,0,0, + 0,0,1,0,0,0,64,0,0,0,115,16,0,0,0,101, + 0,0,90,1,0,100,0,0,90,2,0,100,1,0,83,41, + 2,218,14,95,68,101,97,100,108,111,99,107,69,114,114,111, + 114,78,41,3,114,1,0,0,0,114,0,0,0,0,114,2, + 0,0,0,114,10,0,0,0,114,10,0,0,0,114,10,0, + 0,0,114,11,0,0,0,114,31,0,0,0,64,0,0,0, + 115,2,0,0,0,12,1,114,31,0,0,0,99,0,0,0, + 0,0,0,0,0,0,0,0,0,2,0,0,0,64,0,0, + 0,115,82,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,83,41,13,218,11,95,77,111,100, + 117,108,101,76,111,99,107,122,169,65,32,114,101,99,117,114, + 115,105,118,101,32,108,111,99,107,32,105,109,112,108,101,109, + 101,110,116,97,116,105,111,110,32,119,104,105,99,104,32,105, + 115,32,97,98,108,101,32,116,111,32,100,101,116,101,99,116, + 32,100,101,97,100,108,111,99,107,115,10,32,32,32,32,40, + 101,46,103,46,32,116,104,114,101,97,100,32,49,32,116,114, + 121,105,110,103,32,116,111,32,116,97,107,101,32,108,111,99, + 107,115,32,65,32,116,104,101,110,32,66,44,32,97,110,100, + 32,116,104,114,101,97,100,32,50,32,116,114,121,105,110,103, + 32,116,111,10,32,32,32,32,116,97,107,101,32,108,111,99, + 107,115,32,66,32,116,104,101,110,32,65,41,46,10,32,32, + 32,32,99,2,0,0,0,0,0,0,0,2,0,0,0,2, + 0,0,0,67,0,0,0,115,70,0,0,0,116,0,0,106, + 1,0,131,0,0,124,0,0,95,2,0,116,0,0,106,1, + 0,131,0,0,124,0,0,95,3,0,124,1,0,124,0,0, + 95,4,0,100,0,0,124,0,0,95,5,0,100,1,0,124, + 0,0,95,6,0,100,1,0,124,0,0,95,7,0,100,0, + 0,83,41,2,78,233,0,0,0,0,41,8,218,7,95,116, + 104,114,101,97,100,90,13,97,108,108,111,99,97,116,101,95, + 108,111,99,107,218,4,108,111,99,107,218,6,119,97,107,101, + 117,112,114,15,0,0,0,218,5,111,119,110,101,114,218,5, + 99,111,117,110,116,218,7,119,97,105,116,101,114,115,41,2, + 114,19,0,0,0,114,15,0,0,0,114,10,0,0,0,114, + 10,0,0,0,114,11,0,0,0,114,20,0,0,0,74,0, + 0,0,115,12,0,0,0,0,1,15,1,15,1,9,1,9, + 1,9,1,122,20,95,77,111,100,117,108,101,76,111,99,107, + 46,95,95,105,110,105,116,95,95,99,1,0,0,0,0,0, + 0,0,4,0,0,0,2,0,0,0,67,0,0,0,115,88, + 0,0,0,116,0,0,106,1,0,131,0,0,125,1,0,124, + 0,0,106,2,0,125,2,0,120,60,0,116,3,0,106,4, + 0,124,2,0,131,1,0,125,3,0,124,3,0,100,0,0, + 107,8,0,114,55,0,100,1,0,83,124,3,0,106,2,0, + 125,2,0,124,2,0,124,1,0,107,2,0,114,24,0,100, + 2,0,83,113,24,0,87,100,0,0,83,41,3,78,70,84, + 41,5,114,34,0,0,0,218,9,103,101,116,95,105,100,101, + 110,116,114,37,0,0,0,218,12,95,98,108,111,99,107,105, + 110,103,95,111,110,218,3,103,101,116,41,4,114,19,0,0, + 0,90,2,109,101,218,3,116,105,100,114,35,0,0,0,114, + 10,0,0,0,114,10,0,0,0,114,11,0,0,0,218,12, + 104,97,115,95,100,101,97,100,108,111,99,107,82,0,0,0, + 115,18,0,0,0,0,2,12,1,9,1,3,1,15,1,12, + 1,4,1,9,1,12,1,122,24,95,77,111,100,117,108,101, + 76,111,99,107,46,104,97,115,95,100,101,97,100,108,111,99, + 107,99,1,0,0,0,0,0,0,0,2,0,0,0,16,0, + 0,0,67,0,0,0,115,210,0,0,0,116,0,0,106,1, + 0,131,0,0,125,1,0,124,0,0,116,2,0,124,1,0, + 60,122,173,0,120,166,0,124,0,0,106,3,0,143,124,0, + 1,124,0,0,106,4,0,100,1,0,107,2,0,115,68,0, + 124,0,0,106,5,0,124,1,0,107,2,0,114,96,0,124, + 1,0,124,0,0,95,5,0,124,0,0,4,106,4,0,100, + 2,0,55,2,95,4,0,100,3,0,83,124,0,0,106,6, + 0,131,0,0,114,124,0,116,7,0,100,4,0,124,0,0, + 22,131,1,0,130,1,0,124,0,0,106,8,0,106,9,0, + 100,5,0,131,1,0,114,157,0,124,0,0,4,106,10,0, + 100,2,0,55,2,95,10,0,87,100,6,0,81,82,88,124, + 0,0,106,8,0,106,9,0,131,0,0,1,124,0,0,106, + 8,0,106,11,0,131,0,0,1,113,28,0,87,87,100,6, + 0,116,2,0,124,1,0,61,88,100,6,0,83,41,7,122, + 185,10,32,32,32,32,32,32,32,32,65,99,113,117,105,114, + 101,32,116,104,101,32,109,111,100,117,108,101,32,108,111,99, + 107,46,32,32,73,102,32,97,32,112,111,116,101,110,116,105, + 97,108,32,100,101,97,100,108,111,99,107,32,105,115,32,100, + 101,116,101,99,116,101,100,44,10,32,32,32,32,32,32,32, + 32,97,32,95,68,101,97,100,108,111,99,107,69,114,114,111, + 114,32,105,115,32,114,97,105,115,101,100,46,10,32,32,32, + 32,32,32,32,32,79,116,104,101,114,119,105,115,101,44,32, + 116,104,101,32,108,111,99,107,32,105,115,32,97,108,119,97, + 121,115,32,97,99,113,117,105,114,101,100,32,97,110,100,32, + 84,114,117,101,32,105,115,32,114,101,116,117,114,110,101,100, + 46,10,32,32,32,32,32,32,32,32,114,33,0,0,0,233, + 1,0,0,0,84,122,23,100,101,97,100,108,111,99,107,32, + 100,101,116,101,99,116,101,100,32,98,121,32,37,114,70,78, + 41,12,114,34,0,0,0,114,40,0,0,0,114,41,0,0, + 0,114,35,0,0,0,114,38,0,0,0,114,37,0,0,0, + 114,44,0,0,0,114,31,0,0,0,114,36,0,0,0,218, + 7,97,99,113,117,105,114,101,114,39,0,0,0,218,7,114, + 101,108,101,97,115,101,41,2,114,19,0,0,0,114,43,0, + 0,0,114,10,0,0,0,114,10,0,0,0,114,11,0,0, + 0,114,46,0,0,0,94,0,0,0,115,32,0,0,0,0, + 6,12,1,10,1,3,1,3,1,10,1,30,1,9,1,15, + 1,4,1,12,1,16,1,18,1,22,2,13,1,21,2,122, + 19,95,77,111,100,117,108,101,76,111,99,107,46,97,99,113, + 117,105,114,101,99,1,0,0,0,0,0,0,0,2,0,0, + 0,10,0,0,0,67,0,0,0,115,157,0,0,0,116,0, + 0,106,1,0,131,0,0,125,1,0,124,0,0,106,2,0, + 143,129,0,1,124,0,0,106,3,0,124,1,0,107,3,0, + 114,49,0,116,4,0,100,1,0,131,1,0,130,1,0,124, + 0,0,106,5,0,100,2,0,107,4,0,115,70,0,116,6, + 0,130,1,0,124,0,0,4,106,5,0,100,3,0,56,2, + 95,5,0,124,0,0,106,5,0,100,2,0,107,2,0,114, + 146,0,100,0,0,124,0,0,95,3,0,124,0,0,106,7, + 0,114,146,0,124,0,0,4,106,7,0,100,3,0,56,2, + 95,7,0,124,0,0,106,8,0,106,9,0,131,0,0,1, + 87,100,0,0,81,82,88,100,0,0,83,41,4,78,122,31, + 99,97,110,110,111,116,32,114,101,108,101,97,115,101,32,117, + 110,45,97,99,113,117,105,114,101,100,32,108,111,99,107,114, + 33,0,0,0,114,45,0,0,0,41,10,114,34,0,0,0, + 114,40,0,0,0,114,35,0,0,0,114,37,0,0,0,218, + 12,82,117,110,116,105,109,101,69,114,114,111,114,114,38,0, + 0,0,218,14,65,115,115,101,114,116,105,111,110,69,114,114, + 111,114,114,39,0,0,0,114,36,0,0,0,114,47,0,0, + 0,41,2,114,19,0,0,0,114,43,0,0,0,114,10,0, + 0,0,114,10,0,0,0,114,11,0,0,0,114,47,0,0, + 0,119,0,0,0,115,22,0,0,0,0,1,12,1,10,1, + 15,1,12,1,21,1,15,1,15,1,9,1,9,1,15,1, + 122,19,95,77,111,100,117,108,101,76,111,99,107,46,114,101, + 108,101,97,115,101,99,1,0,0,0,0,0,0,0,1,0, + 0,0,4,0,0,0,67,0,0,0,115,25,0,0,0,100, + 1,0,106,0,0,124,0,0,106,1,0,116,2,0,124,0, + 0,131,1,0,131,2,0,83,41,2,78,122,23,95,77,111, 100,117,108,101,76,111,99,107,40,123,33,114,125,41,32,97, - 116,32,123,125,41,3,114,47,0,0,0,114,67,0,0,0, - 114,48,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, - 251,0,0,0,115,2,0,0,0,0,1,122,25,95,68,117, - 109,109,121,77,111,100,117,108,101,76,111,99,107,46,95,95, - 114,101,112,114,95,95,78,41,8,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,97,0,0,0,114,98,0,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,102,0,0,0,234,0,0,0,115,10, - 0,0,0,12,2,6,2,12,4,12,4,12,5,114,102,0, - 0,0,99,0,0,0,0,0,0,0,0,0,0,0,0,2, - 0,0,0,64,0,0,0,115,52,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,100,3,0,100,4,0,132,0,0,90,4,0, - 100,5,0,100,6,0,132,0,0,90,5,0,100,7,0,83, - 41,8,218,18,95,77,111,100,117,108,101,76,111,99,107,77, - 97,110,97,103,101,114,99,2,0,0,0,0,0,0,0,2, - 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,100,0,0,124,0,0,95, - 1,0,100,0,0,83,41,1,78,41,2,114,70,0,0,0, - 218,5,95,108,111,99,107,41,2,114,71,0,0,0,114,67, - 0,0,0,114,4,0,0,0,114,4,0,0,0,114,5,0, - 0,0,114,72,0,0,0,1,1,0,0,115,4,0,0,0, - 0,1,9,1,122,27,95,77,111,100,117,108,101,76,111,99, - 107,77,97,110,97,103,101,114,46,95,95,105,110,105,116,95, - 95,99,1,0,0,0,0,0,0,0,1,0,0,0,10,0, - 0,0,67,0,0,0,115,53,0,0,0,122,22,0,116,0, - 0,124,0,0,106,1,0,131,1,0,124,0,0,95,2,0, - 87,100,0,0,116,3,0,106,4,0,131,0,0,1,88,124, - 0,0,106,2,0,106,5,0,131,0,0,1,100,0,0,83, - 41,1,78,41,6,218,16,95,103,101,116,95,109,111,100,117, - 108,101,95,108,111,99,107,114,70,0,0,0,114,104,0,0, - 0,218,4,95,105,109,112,218,12,114,101,108,101,97,115,101, - 95,108,111,99,107,114,97,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,5,1,0,0,115,8,0,0,0,0,1, - 3,1,22,2,11,1,122,28,95,77,111,100,117,108,101,76, - 111,99,107,77,97,110,97,103,101,114,46,95,95,101,110,116, - 101,114,95,95,99,1,0,0,0,0,0,0,0,3,0,0, - 0,1,0,0,0,79,0,0,0,115,17,0,0,0,124,0, - 0,106,0,0,106,1,0,131,0,0,1,100,0,0,83,41, - 1,78,41,2,114,104,0,0,0,114,98,0,0,0,41,3, - 114,71,0,0,0,114,80,0,0,0,218,6,107,119,97,114, - 103,115,114,4,0,0,0,114,4,0,0,0,114,5,0,0, - 0,114,81,0,0,0,12,1,0,0,115,2,0,0,0,0, - 1,122,27,95,77,111,100,117,108,101,76,111,99,107,77,97, - 110,97,103,101,114,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,103,0,0,0,255,0,0,0,115,6,0,0, - 0,12,2,12,4,12,7,114,103,0,0,0,99,1,0,0, - 0,0,0,0,0,3,0,0,0,11,0,0,0,3,0,0, - 0,115,142,0,0,0,100,1,0,125,1,0,121,17,0,116, - 0,0,136,0,0,25,131,0,0,125,1,0,87,110,18,0, - 4,116,1,0,107,10,0,114,43,0,1,1,1,89,110,1, - 0,88,124,1,0,100,1,0,107,8,0,114,138,0,116,2, - 0,100,1,0,107,8,0,114,83,0,116,3,0,136,0,0, - 131,1,0,125,1,0,110,12,0,116,4,0,136,0,0,131, - 1,0,125,1,0,135,0,0,102,1,0,100,2,0,100,3, - 0,134,0,0,125,2,0,116,5,0,106,6,0,124,1,0, - 124,2,0,131,2,0,116,0,0,136,0,0,60,110,0,0, - 124,1,0,83,41,4,122,109,71,101,116,32,111,114,32,99, - 114,101,97,116,101,32,116,104,101,32,109,111,100,117,108,101, - 32,108,111,99,107,32,102,111,114,32,97,32,103,105,118,101, - 110,32,109,111,100,117,108,101,32,110,97,109,101,46,10,10, - 32,32,32,32,83,104,111,117,108,100,32,111,110,108,121,32, - 98,101,32,99,97,108,108,101,100,32,119,105,116,104,32,116, - 104,101,32,105,109,112,111,114,116,32,108,111,99,107,32,116, - 97,107,101,110,46,78,99,1,0,0,0,0,0,0,0,1, - 0,0,0,2,0,0,0,19,0,0,0,115,11,0,0,0, - 116,0,0,136,0,0,61,100,0,0,83,41,1,78,41,1, - 218,13,95,109,111,100,117,108,101,95,108,111,99,107,115,41, - 1,114,36,0,0,0,41,1,114,67,0,0,0,114,4,0, - 0,0,114,5,0,0,0,218,2,99,98,32,1,0,0,115, - 2,0,0,0,0,1,122,28,95,103,101,116,95,109,111,100, - 117,108,101,95,108,111,99,107,46,60,108,111,99,97,108,115, - 62,46,99,98,41,7,114,109,0,0,0,114,79,0,0,0, - 114,85,0,0,0,114,102,0,0,0,114,83,0,0,0,218, - 8,95,119,101,97,107,114,101,102,90,3,114,101,102,41,3, - 114,67,0,0,0,114,86,0,0,0,114,110,0,0,0,114, - 4,0,0,0,41,1,114,67,0,0,0,114,5,0,0,0, - 114,105,0,0,0,18,1,0,0,115,24,0,0,0,0,4, - 6,1,3,1,17,1,13,1,5,1,12,1,12,1,15,2, - 12,1,18,2,25,1,114,105,0,0,0,99,1,0,0,0, - 0,0,0,0,2,0,0,0,11,0,0,0,67,0,0,0, - 115,71,0,0,0,116,0,0,124,0,0,131,1,0,125,1, - 0,116,1,0,106,2,0,131,0,0,1,121,14,0,124,1, - 0,106,3,0,131,0,0,1,87,110,18,0,4,116,4,0, - 107,10,0,114,56,0,1,1,1,89,110,11,0,88,124,1, - 0,106,5,0,131,0,0,1,100,1,0,83,41,2,97,21, - 1,0,0,82,101,108,101,97,115,101,32,116,104,101,32,103, - 108,111,98,97,108,32,105,109,112,111,114,116,32,108,111,99, - 107,44,32,97,110,100,32,97,99,113,117,105,114,101,115,32, - 116,104,101,110,32,114,101,108,101,97,115,101,32,116,104,101, - 10,32,32,32,32,109,111,100,117,108,101,32,108,111,99,107, - 32,102,111,114,32,97,32,103,105,118,101,110,32,109,111,100, - 117,108,101,32,110,97,109,101,46,10,32,32,32,32,84,104, - 105,115,32,105,115,32,117,115,101,100,32,116,111,32,101,110, - 115,117,114,101,32,97,32,109,111,100,117,108,101,32,105,115, - 32,99,111,109,112,108,101,116,101,108,121,32,105,110,105,116, - 105,97,108,105,122,101,100,44,32,105,110,32,116,104,101,10, - 32,32,32,32,101,118,101,110,116,32,105,116,32,105,115,32, - 98,101,105,110,103,32,105,109,112,111,114,116,101,100,32,98, - 121,32,97,110,111,116,104,101,114,32,116,104,114,101,97,100, - 46,10,10,32,32,32,32,83,104,111,117,108,100,32,111,110, - 108,121,32,98,101,32,99,97,108,108,101,100,32,119,105,116, - 104,32,116,104,101,32,105,109,112,111,114,116,32,108,111,99, - 107,32,116,97,107,101,110,46,78,41,6,114,105,0,0,0, - 114,106,0,0,0,114,107,0,0,0,114,97,0,0,0,114, - 82,0,0,0,114,98,0,0,0,41,2,114,67,0,0,0, - 114,86,0,0,0,114,4,0,0,0,114,4,0,0,0,114, - 5,0,0,0,218,19,95,108,111,99,107,95,117,110,108,111, - 99,107,95,109,111,100,117,108,101,37,1,0,0,115,14,0, - 0,0,0,7,12,1,10,1,3,1,14,1,13,3,5,2, - 114,112,0,0,0,99,1,0,0,0,0,0,0,0,3,0, - 0,0,3,0,0,0,79,0,0,0,115,13,0,0,0,124, - 0,0,124,1,0,124,2,0,142,0,0,83,41,1,97,46, - 1,0,0,114,101,109,111,118,101,95,105,109,112,111,114,116, - 108,105,98,95,102,114,97,109,101,115,32,105,110,32,105,109, - 112,111,114,116,46,99,32,119,105,108,108,32,97,108,119,97, - 121,115,32,114,101,109,111,118,101,32,115,101,113,117,101,110, - 99,101,115,10,32,32,32,32,111,102,32,105,109,112,111,114, - 116,108,105,98,32,102,114,97,109,101,115,32,116,104,97,116, - 32,101,110,100,32,119,105,116,104,32,97,32,99,97,108,108, - 32,116,111,32,116,104,105,115,32,102,117,110,99,116,105,111, - 110,10,10,32,32,32,32,85,115,101,32,105,116,32,105,110, - 115,116,101,97,100,32,111,102,32,97,32,110,111,114,109,97, - 108,32,99,97,108,108,32,105,110,32,112,108,97,99,101,115, - 32,119,104,101,114,101,32,105,110,99,108,117,100,105,110,103, - 32,116,104,101,32,105,109,112,111,114,116,108,105,98,10,32, - 32,32,32,102,114,97,109,101,115,32,105,110,116,114,111,100, - 117,99,101,115,32,117,110,119,97,110,116,101,100,32,110,111, - 105,115,101,32,105,110,116,111,32,116,104,101,32,116,114,97, - 99,101,98,97,99,107,32,40,101,46,103,46,32,119,104,101, - 110,32,101,120,101,99,117,116,105,110,103,10,32,32,32,32, - 109,111,100,117,108,101,32,99,111,100,101,41,10,32,32,32, - 32,114,4,0,0,0,41,3,218,1,102,114,80,0,0,0, - 90,4,107,119,100,115,114,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,238,12,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,0,0,0,0,0,0,0,11,0, - 0,0,6,0,0,0,67,0,0,0,115,192,0,0,0,124, - 1,0,100,1,0,107,8,0,114,25,0,116,0,0,106,1, - 0,106,2,0,12,110,3,0,124,1,0,125,2,0,124,2, - 0,114,46,0,116,3,0,125,3,0,110,6,0,116,4,0, - 125,3,0,116,5,0,124,0,0,131,1,0,92,2,0,125, - 4,0,125,5,0,124,5,0,106,6,0,100,2,0,131,1, - 0,92,3,0,125,6,0,125,7,0,125,8,0,116,0,0, - 106,7,0,106,8,0,125,9,0,124,9,0,100,1,0,107, - 8,0,114,133,0,116,9,0,100,3,0,131,1,0,130,1, - 0,110,0,0,100,4,0,106,10,0,124,6,0,114,151,0, - 124,6,0,110,3,0,124,8,0,124,7,0,124,9,0,124, - 3,0,100,5,0,25,103,4,0,131,1,0,125,10,0,116, - 11,0,124,4,0,116,12,0,124,10,0,131,3,0,83,41, - 6,97,244,1,0,0,71,105,118,101,110,32,116,104,101,32, - 112,97,116,104,32,116,111,32,97,32,46,112,121,32,102,105, - 108,101,44,32,114,101,116,117,114,110,32,116,104,101,32,112, - 97,116,104,32,116,111,32,105,116,115,32,46,112,121,99,47, - 46,112,121,111,32,102,105,108,101,46,10,10,32,32,32,32, - 84,104,101,32,46,112,121,32,102,105,108,101,32,100,111,101, - 115,32,110,111,116,32,110,101,101,100,32,116,111,32,101,120, - 105,115,116,59,32,116,104,105,115,32,115,105,109,112,108,121, - 32,114,101,116,117,114,110,115,32,116,104,101,32,112,97,116, - 104,32,116,111,32,116,104,101,10,32,32,32,32,46,112,121, - 99,47,46,112,121,111,32,102,105,108,101,32,99,97,108,99, - 117,108,97,116,101,100,32,97,115,32,105,102,32,116,104,101, - 32,46,112,121,32,102,105,108,101,32,119,101,114,101,32,105, - 109,112,111,114,116,101,100,46,32,32,84,104,101,32,101,120, - 116,101,110,115,105,111,110,10,32,32,32,32,119,105,108,108, - 32,98,101,32,46,112,121,99,32,117,110,108,101,115,115,32, - 115,121,115,46,102,108,97,103,115,46,111,112,116,105,109,105, - 122,101,32,105,115,32,110,111,110,45,122,101,114,111,44,32, - 116,104,101,110,32,105,116,32,119,105,108,108,32,98,101,32, - 46,112,121,111,46,10,10,32,32,32,32,73,102,32,100,101, - 98,117,103,95,111,118,101,114,114,105,100,101,32,105,115,32, - 110,111,116,32,78,111,110,101,44,32,116,104,101,110,32,105, - 116,32,109,117,115,116,32,98,101,32,97,32,98,111,111,108, - 101,97,110,32,97,110,100,32,105,115,32,117,115,101,100,32, - 105,110,10,32,32,32,32,112,108,97,99,101,32,111,102,32, - 115,121,115,46,102,108,97,103,115,46,111,112,116,105,109,105, - 122,101,46,10,10,32,32,32,32,73,102,32,115,121,115,46, - 105,109,112,108,101,109,101,110,116,97,116,105,111,110,46,99, - 97,99,104,101,95,116,97,103,32,105,115,32,78,111,110,101, - 32,116,104,101,110,32,78,111,116,73,109,112,108,101,109,101, - 110,116,101,100,69,114,114,111,114,32,105,115,32,114,97,105, - 115,101,100,46,10,10,32,32,32,32,78,218,1,46,122,36, - 115,121,115,46,105,109,112,108,101,109,101,110,116,97,116,105, - 111,110,46,99,97,99,104,101,95,116,97,103,32,105,115,32, - 78,111,110,101,114,30,0,0,0,114,84,0,0,0,41,13, - 114,7,0,0,0,218,5,102,108,97,103,115,218,8,111,112, - 116,105,109,105,122,101,218,23,68,69,66,85,71,95,66,89, - 84,69,67,79,68,69,95,83,85,70,70,73,88,69,83,218, - 27,79,80,84,73,77,73,90,69,68,95,66,89,84,69,67, - 79,68,69,95,83,85,70,70,73,88,69,83,114,38,0,0, - 0,114,32,0,0,0,218,14,105,109,112,108,101,109,101,110, - 116,97,116,105,111,110,218,9,99,97,99,104,101,95,116,97, - 103,218,19,78,111,116,73,109,112,108,101,109,101,110,116,101, - 100,69,114,114,111,114,114,26,0,0,0,114,28,0,0,0, - 218,8,95,80,89,67,65,67,72,69,41,11,114,35,0,0, - 0,90,14,100,101,98,117,103,95,111,118,101,114,114,105,100, - 101,218,5,100,101,98,117,103,218,8,115,117,102,102,105,120, - 101,115,218,4,104,101,97,100,114,37,0,0,0,218,4,98, - 97,115,101,218,3,115,101,112,218,4,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,181, - 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,15,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,193,0,0,0,116,0,0, - 106,1,0,106,2,0,100,1,0,107,8,0,114,33,0,116, - 3,0,100,2,0,131,1,0,130,1,0,110,0,0,116,4, - 0,124,0,0,131,1,0,92,2,0,125,1,0,125,2,0, - 116,4,0,124,1,0,131,1,0,92,2,0,125,1,0,125, - 3,0,124,3,0,116,5,0,107,3,0,114,108,0,116,6, - 0,100,3,0,106,7,0,116,5,0,124,0,0,131,2,0, - 131,1,0,130,1,0,110,0,0,124,2,0,106,8,0,100, - 4,0,131,1,0,100,5,0,107,3,0,114,153,0,116,6, - 0,100,6,0,106,7,0,124,2,0,131,1,0,131,1,0, - 130,1,0,110,0,0,124,2,0,106,9,0,100,4,0,131, - 1,0,100,7,0,25,125,4,0,116,10,0,124,1,0,124, - 4,0,116,11,0,100,7,0,25,23,131,2,0,83,41,8, - 97,121,1,0,0,71,105,118,101,110,32,116,104,101,32,112, - 97,116,104,32,116,111,32,97,32,46,112,121,99,46,47,46, - 112,121,111,32,102,105,108,101,44,32,114,101,116,117,114,110, - 32,116,104,101,32,112,97,116,104,32,116,111,32,105,116,115, - 32,46,112,121,32,102,105,108,101,46,10,10,32,32,32,32, - 84,104,101,32,46,112,121,99,47,46,112,121,111,32,102,105, - 108,101,32,100,111,101,115,32,110,111,116,32,110,101,101,100, - 32,116,111,32,101,120,105,115,116,59,32,116,104,105,115,32, - 115,105,109,112,108,121,32,114,101,116,117,114,110,115,32,116, - 104,101,32,112,97,116,104,32,116,111,10,32,32,32,32,116, - 104,101,32,46,112,121,32,102,105,108,101,32,99,97,108,99, - 117,108,97,116,101,100,32,116,111,32,99,111,114,114,101,115, - 112,111,110,100,32,116,111,32,116,104,101,32,46,112,121,99, - 47,46,112,121,111,32,102,105,108,101,46,32,32,73,102,32, - 112,97,116,104,32,100,111,101,115,10,32,32,32,32,110,111, - 116,32,99,111,110,102,111,114,109,32,116,111,32,80,69,80, - 32,51,49,52,55,32,102,111,114,109,97,116,44,32,86,97, - 108,117,101,69,114,114,111,114,32,119,105,108,108,32,98,101, - 32,114,97,105,115,101,100,46,32,73,102,10,32,32,32,32, - 115,121,115,46,105,109,112,108,101,109,101,110,116,97,116,105, - 111,110,46,99,97,99,104,101,95,116,97,103,32,105,115,32, - 78,111,110,101,32,116,104,101,110,32,78,111,116,73,109,112, - 108,101,109,101,110,116,101,100,69,114,114,111,114,32,105,115, - 32,114,97,105,115,101,100,46,10,10,32,32,32,32,78,122, - 36,115,121,115,46,105,109,112,108,101,109,101,110,116,97,116, - 105,111,110,46,99,97,99,104,101,95,116,97,103,32,105,115, - 32,78,111,110,101,122,37,123,125,32,110,111,116,32,98,111, - 116,116,111,109,45,108,101,118,101,108,32,100,105,114,101,99, - 116,111,114,121,32,105,110,32,123,33,114,125,114,116,0,0, - 0,114,115,0,0,0,122,28,101,120,112,101,99,116,101,100, - 32,111,110,108,121,32,50,32,100,111,116,115,32,105,110,32, - 123,33,114,125,114,84,0,0,0,41,12,114,7,0,0,0, - 114,121,0,0,0,114,122,0,0,0,114,123,0,0,0,114, - 38,0,0,0,114,124,0,0,0,218,10,86,97,108,117,101, - 69,114,114,111,114,114,47,0,0,0,114,89,0,0,0,218, - 9,112,97,114,116,105,116,105,111,110,114,28,0,0,0,218, - 15,83,79,85,82,67,69,95,83,85,70,70,73,88,69,83, - 41,5,114,35,0,0,0,114,127,0,0,0,90,16,112,121, - 99,97,99,104,101,95,102,105,108,101,110,97,109,101,90,7, - 112,121,99,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,208,1,0,0,115,24,0,0, - 0,0,9,18,1,15,1,18,1,18,1,12,1,9,1,18, - 1,21,1,9,1,15,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,115,164,0,0,0,116,0,0,124,0,0,131,1, - 0,100,1,0,107,2,0,114,22,0,100,2,0,83,124,0, - 0,106,1,0,100,3,0,131,1,0,92,3,0,125,1,0, - 125,2,0,125,3,0,124,1,0,12,115,81,0,124,3,0, - 106,2,0,131,0,0,100,7,0,100,8,0,133,2,0,25, - 100,6,0,107,3,0,114,85,0,124,0,0,83,121,16,0, - 116,3,0,124,0,0,131,1,0,125,4,0,87,110,40,0, - 4,116,4,0,116,5,0,102,2,0,107,10,0,114,143,0, - 1,1,1,124,0,0,100,2,0,100,9,0,133,2,0,25, - 125,4,0,89,110,1,0,88,116,6,0,124,4,0,131,1, - 0,114,160,0,124,4,0,83,124,0,0,83,41,10,122,188, - 67,111,110,118,101,114,116,32,97,32,98,121,116,101,99,111, - 100,101,32,102,105,108,101,32,112,97,116,104,32,116,111,32, - 97,32,115,111,117,114,99,101,32,112,97,116,104,32,40,105, - 102,32,112,111,115,115,105,98,108,101,41,46,10,10,32,32, - 32,32,84,104,105,115,32,102,117,110,99,116,105,111,110,32, - 101,120,105,115,116,115,32,112,117,114,101,108,121,32,102,111, - 114,32,98,97,99,107,119,97,114,100,115,45,99,111,109,112, - 97,116,105,98,105,108,105,116,121,32,102,111,114,10,32,32, - 32,32,80,121,73,109,112,111,114,116,95,69,120,101,99,67, - 111,100,101,77,111,100,117,108,101,87,105,116,104,70,105,108, - 101,110,97,109,101,115,40,41,32,105,110,32,116,104,101,32, - 67,32,65,80,73,46,10,10,32,32,32,32,114,84,0,0, - 0,78,114,116,0,0,0,233,3,0,0,0,114,29,0,0, - 0,90,2,112,121,233,253,255,255,255,233,255,255,255,255,114, - 139,0,0,0,41,7,114,31,0,0,0,114,32,0,0,0, - 218,5,108,111,119,101,114,114,136,0,0,0,114,123,0,0, - 0,114,133,0,0,0,114,44,0,0,0,41,5,218,13,98, - 121,116,101,99,111,100,101,95,112,97,116,104,114,130,0,0, - 0,114,36,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,231,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,0,0,115,60,0,0,0,121,19,0,116,0,0, - 124,0,0,131,1,0,106,1,0,125,1,0,87,110,24,0, - 4,116,2,0,107,10,0,114,45,0,1,1,1,100,1,0, - 125,1,0,89,110,1,0,88,124,1,0,100,2,0,79,125, - 1,0,124,1,0,83,41,3,122,51,67,97,108,99,117,108, - 97,116,101,32,116,104,101,32,109,111,100,101,32,112,101,114, - 109,105,115,115,105,111,110,115,32,102,111,114,32,97,32,98, - 121,116,101,99,111,100,101,32,102,105,108,101,46,105,182,1, - 0,0,233,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,250, - 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,0,0,0,4,0,0,0,71,0,0,0,115,81, - 0,0,0,116,0,0,106,1,0,106,2,0,124,1,0,107, - 5,0,114,77,0,124,0,0,106,3,0,100,6,0,131,1, - 0,115,46,0,100,3,0,124,0,0,23,125,0,0,110,0, - 0,116,4,0,124,0,0,106,5,0,124,2,0,140,0,0, - 100,4,0,116,0,0,106,6,0,131,1,1,1,110,0,0, - 100,5,0,83,41,7,122,61,80,114,105,110,116,32,116,104, - 101,32,109,101,115,115,97,103,101,32,116,111,32,115,116,100, - 101,114,114,32,105,102,32,45,118,47,80,89,84,72,79,78, - 86,69,82,66,79,83,69,32,105,115,32,116,117,114,110,101, - 100,32,111,110,46,250,1,35,250,7,105,109,112,111,114,116, - 32,122,2,35,32,114,54,0,0,0,78,41,2,114,147,0, - 0,0,114,148,0,0,0,41,7,114,7,0,0,0,114,117, - 0,0,0,218,7,118,101,114,98,111,115,101,114,9,0,0, - 0,218,5,112,114,105,110,116,114,47,0,0,0,218,6,115, - 116,100,101,114,114,41,3,218,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,6,2,0,0,115, - 8,0,0,0,0,2,18,1,15,1,13,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,0,134,1,0,125,1,0, - 116,0,0,124,1,0,136,0,0,131,2,0,1,124,1,0, - 83,41,4,122,252,68,101,99,111,114,97,116,111,114,32,116, - 111,32,118,101,114,105,102,121,32,116,104,97,116,32,116,104, - 101,32,109,111,100,117,108,101,32,98,101,105,110,103,32,114, - 101,113,117,101,115,116,101,100,32,109,97,116,99,104,101,115, - 32,116,104,101,32,111,110,101,32,116,104,101,10,32,32,32, - 32,108,111,97,100,101,114,32,99,97,110,32,104,97,110,100, - 108,101,46,10,10,32,32,32,32,84,104,101,32,102,105,114, - 115,116,32,97,114,103,117,109,101,110,116,32,40,115,101,108, - 102,41,32,109,117,115,116,32,100,101,102,105,110,101,32,95, - 110,97,109,101,32,119,104,105,99,104,32,116,104,101,32,115, - 101,99,111,110,100,32,97,114,103,117,109,101,110,116,32,105, - 115,10,32,32,32,32,99,111,109,112,97,114,101,100,32,97, - 103,97,105,110,115,116,46,32,73,102,32,116,104,101,32,99, - 111,109,112,97,114,105,115,111,110,32,102,97,105,108,115,32, - 116,104,101,110,32,73,109,112,111,114,116,69,114,114,111,114, - 32,105,115,32,114,97,105,115,101,100,46,10,10,32,32,32, - 32,78,99,2,0,0,0,0,0,0,0,4,0,0,0,5, - 0,0,0,31,0,0,0,115,83,0,0,0,124,1,0,100, - 0,0,107,8,0,114,24,0,124,0,0,106,0,0,125,1, - 0,110,40,0,124,0,0,106,0,0,124,1,0,107,3,0, - 114,64,0,116,1,0,100,1,0,124,1,0,22,100,2,0, - 124,1,0,131,1,1,130,1,0,110,0,0,136,0,0,124, - 0,0,124,1,0,124,2,0,124,3,0,142,2,0,83,41, - 3,78,122,23,108,111,97,100,101,114,32,99,97,110,110,111, - 116,32,104,97,110,100,108,101,32,37,115,114,67,0,0,0, - 41,2,114,67,0,0,0,218,11,73,109,112,111,114,116,69, - 114,114,111,114,41,4,114,71,0,0,0,114,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,22,2,0,0,115,10,0,0,0,0,1,12,1, - 12,1,15,1,25,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,14,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,0,0,125,1, - 0,116,0,0,124,1,0,136,0,0,131,2,0,1,124,1, - 0,83,41,3,122,49,68,101,99,111,114,97,116,111,114,32, - 116,111,32,118,101,114,105,102,121,32,116,104,101,32,110,97, - 109,101,100,32,109,111,100,117,108,101,32,105,115,32,98,117, - 105,108,116,45,105,110,46,99,2,0,0,0,0,0,0,0, - 2,0,0,0,4,0,0,0,19,0,0,0,115,58,0,0, - 0,124,1,0,116,0,0,106,1,0,107,7,0,114,45,0, + 116,32,123,125,41,3,218,6,102,111,114,109,97,116,114,15, + 0,0,0,218,2,105,100,41,1,114,19,0,0,0,114,10, + 0,0,0,114,10,0,0,0,114,11,0,0,0,218,8,95, + 95,114,101,112,114,95,95,132,0,0,0,115,2,0,0,0, + 0,1,122,20,95,77,111,100,117,108,101,76,111,99,107,46, + 95,95,114,101,112,114,95,95,78,41,9,114,1,0,0,0, + 114,0,0,0,0,114,2,0,0,0,114,3,0,0,0,114, + 20,0,0,0,114,44,0,0,0,114,46,0,0,0,114,47, + 0,0,0,114,52,0,0,0,114,10,0,0,0,114,10,0, + 0,0,114,10,0,0,0,114,11,0,0,0,114,32,0,0, + 0,68,0,0,0,115,12,0,0,0,12,4,6,2,12,8, + 12,12,12,25,12,13,114,32,0,0,0,99,0,0,0,0, + 0,0,0,0,0,0,0,0,2,0,0,0,64,0,0,0, + 115,70,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,83,41,11,218,16,95, + 68,117,109,109,121,77,111,100,117,108,101,76,111,99,107,122, + 86,65,32,115,105,109,112,108,101,32,95,77,111,100,117,108, + 101,76,111,99,107,32,101,113,117,105,118,97,108,101,110,116, + 32,102,111,114,32,80,121,116,104,111,110,32,98,117,105,108, + 100,115,32,119,105,116,104,111,117,116,10,32,32,32,32,109, + 117,108,116,105,45,116,104,114,101,97,100,105,110,103,32,115, + 117,112,112,111,114,116,46,99,2,0,0,0,0,0,0,0, + 2,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,100,1,0,124,0,0, + 95,1,0,100,0,0,83,41,2,78,114,33,0,0,0,41, + 2,114,15,0,0,0,114,38,0,0,0,41,2,114,19,0, + 0,0,114,15,0,0,0,114,10,0,0,0,114,10,0,0, + 0,114,11,0,0,0,114,20,0,0,0,140,0,0,0,115, + 4,0,0,0,0,1,9,1,122,25,95,68,117,109,109,121, + 77,111,100,117,108,101,76,111,99,107,46,95,95,105,110,105, + 116,95,95,99,1,0,0,0,0,0,0,0,1,0,0,0, + 3,0,0,0,67,0,0,0,115,19,0,0,0,124,0,0, + 4,106,0,0,100,1,0,55,2,95,0,0,100,2,0,83, + 41,3,78,114,45,0,0,0,84,41,1,114,38,0,0,0, + 41,1,114,19,0,0,0,114,10,0,0,0,114,10,0,0, + 0,114,11,0,0,0,114,46,0,0,0,144,0,0,0,115, + 4,0,0,0,0,1,15,1,122,24,95,68,117,109,109,121, + 77,111,100,117,108,101,76,111,99,107,46,97,99,113,117,105, + 114,101,99,1,0,0,0,0,0,0,0,1,0,0,0,3, + 0,0,0,67,0,0,0,115,46,0,0,0,124,0,0,106, + 0,0,100,1,0,107,2,0,114,27,0,116,1,0,100,2, + 0,131,1,0,130,1,0,124,0,0,4,106,0,0,100,3, + 0,56,2,95,0,0,100,0,0,83,41,4,78,114,33,0, + 0,0,122,31,99,97,110,110,111,116,32,114,101,108,101,97, + 115,101,32,117,110,45,97,99,113,117,105,114,101,100,32,108, + 111,99,107,114,45,0,0,0,41,2,114,38,0,0,0,114, + 48,0,0,0,41,1,114,19,0,0,0,114,10,0,0,0, + 114,10,0,0,0,114,11,0,0,0,114,47,0,0,0,148, + 0,0,0,115,6,0,0,0,0,1,15,1,12,1,122,24, + 95,68,117,109,109,121,77,111,100,117,108,101,76,111,99,107, + 46,114,101,108,101,97,115,101,99,1,0,0,0,0,0,0, + 0,1,0,0,0,4,0,0,0,67,0,0,0,115,25,0, + 0,0,100,1,0,106,0,0,124,0,0,106,1,0,116,2, + 0,124,0,0,131,1,0,131,2,0,83,41,2,78,122,28, + 95,68,117,109,109,121,77,111,100,117,108,101,76,111,99,107, + 40,123,33,114,125,41,32,97,116,32,123,125,41,3,114,50, + 0,0,0,114,15,0,0,0,114,51,0,0,0,41,1,114, + 19,0,0,0,114,10,0,0,0,114,10,0,0,0,114,11, + 0,0,0,114,52,0,0,0,153,0,0,0,115,2,0,0, + 0,0,1,122,25,95,68,117,109,109,121,77,111,100,117,108, + 101,76,111,99,107,46,95,95,114,101,112,114,95,95,78,41, + 8,114,1,0,0,0,114,0,0,0,0,114,2,0,0,0, + 114,3,0,0,0,114,20,0,0,0,114,46,0,0,0,114, + 47,0,0,0,114,52,0,0,0,114,10,0,0,0,114,10, + 0,0,0,114,10,0,0,0,114,11,0,0,0,114,53,0, + 0,0,136,0,0,0,115,10,0,0,0,12,2,6,2,12, + 4,12,4,12,5,114,53,0,0,0,99,0,0,0,0,0, + 0,0,0,0,0,0,0,2,0,0,0,64,0,0,0,115, + 52,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,100,3,0,100, + 4,0,132,0,0,90,4,0,100,5,0,100,6,0,132,0, + 0,90,5,0,100,7,0,83,41,8,218,18,95,77,111,100, + 117,108,101,76,111,99,107,77,97,110,97,103,101,114,99,2, + 0,0,0,0,0,0,0,2,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,100,0,0,124,0,0,95,1,0,100,0,0,83,41,1, + 78,41,2,114,18,0,0,0,218,5,95,108,111,99,107,41, + 2,114,19,0,0,0,114,15,0,0,0,114,10,0,0,0, + 114,10,0,0,0,114,11,0,0,0,114,20,0,0,0,159, + 0,0,0,115,4,0,0,0,0,1,9,1,122,27,95,77, + 111,100,117,108,101,76,111,99,107,77,97,110,97,103,101,114, + 46,95,95,105,110,105,116,95,95,99,1,0,0,0,0,0, + 0,0,1,0,0,0,10,0,0,0,67,0,0,0,115,53, + 0,0,0,122,22,0,116,0,0,124,0,0,106,1,0,131, + 1,0,124,0,0,95,2,0,87,100,0,0,116,3,0,106, + 4,0,131,0,0,1,88,124,0,0,106,2,0,106,5,0, + 131,0,0,1,100,0,0,83,41,1,78,41,6,218,16,95, + 103,101,116,95,109,111,100,117,108,101,95,108,111,99,107,114, + 18,0,0,0,114,55,0,0,0,218,4,95,105,109,112,218, + 12,114,101,108,101,97,115,101,95,108,111,99,107,114,46,0, + 0,0,41,1,114,19,0,0,0,114,10,0,0,0,114,10, + 0,0,0,114,11,0,0,0,114,23,0,0,0,163,0,0, + 0,115,8,0,0,0,0,1,3,1,22,2,11,1,122,28, + 95,77,111,100,117,108,101,76,111,99,107,77,97,110,97,103, + 101,114,46,95,95,101,110,116,101,114,95,95,99,1,0,0, + 0,0,0,0,0,3,0,0,0,1,0,0,0,79,0,0, + 0,115,17,0,0,0,124,0,0,106,0,0,106,1,0,131, + 0,0,1,100,0,0,83,41,1,78,41,2,114,55,0,0, + 0,114,47,0,0,0,41,3,114,19,0,0,0,114,29,0, + 0,0,90,6,107,119,97,114,103,115,114,10,0,0,0,114, + 10,0,0,0,114,11,0,0,0,114,30,0,0,0,170,0, + 0,0,115,2,0,0,0,0,1,122,27,95,77,111,100,117, + 108,101,76,111,99,107,77,97,110,97,103,101,114,46,95,95, + 101,120,105,116,95,95,78,41,6,114,1,0,0,0,114,0, + 0,0,0,114,2,0,0,0,114,20,0,0,0,114,23,0, + 0,0,114,30,0,0,0,114,10,0,0,0,114,10,0,0, + 0,114,10,0,0,0,114,11,0,0,0,114,54,0,0,0, + 157,0,0,0,115,6,0,0,0,12,2,12,4,12,7,114, + 54,0,0,0,99,1,0,0,0,0,0,0,0,3,0,0, + 0,11,0,0,0,3,0,0,0,115,139,0,0,0,100,1, + 0,125,1,0,121,17,0,116,0,0,136,0,0,25,131,0, + 0,125,1,0,87,110,18,0,4,116,1,0,107,10,0,114, + 43,0,1,1,1,89,110,1,0,88,124,1,0,100,1,0, + 107,8,0,114,135,0,116,2,0,100,1,0,107,8,0,114, + 83,0,116,3,0,136,0,0,131,1,0,125,1,0,110,12, + 0,116,4,0,136,0,0,131,1,0,125,1,0,135,0,0, + 102,1,0,100,2,0,100,3,0,134,0,0,125,2,0,116, + 5,0,106,6,0,124,1,0,124,2,0,131,2,0,116,0, + 0,136,0,0,60,124,1,0,83,41,4,122,109,71,101,116, + 32,111,114,32,99,114,101,97,116,101,32,116,104,101,32,109, + 111,100,117,108,101,32,108,111,99,107,32,102,111,114,32,97, + 32,103,105,118,101,110,32,109,111,100,117,108,101,32,110,97, + 109,101,46,10,10,32,32,32,32,83,104,111,117,108,100,32, + 111,110,108,121,32,98,101,32,99,97,108,108,101,100,32,119, + 105,116,104,32,116,104,101,32,105,109,112,111,114,116,32,108, + 111,99,107,32,116,97,107,101,110,46,78,99,1,0,0,0, + 0,0,0,0,1,0,0,0,2,0,0,0,19,0,0,0, + 115,11,0,0,0,116,0,0,136,0,0,61,100,0,0,83, + 41,1,78,41,1,218,13,95,109,111,100,117,108,101,95,108, + 111,99,107,115,41,1,218,1,95,41,1,114,15,0,0,0, + 114,10,0,0,0,114,11,0,0,0,218,2,99,98,190,0, + 0,0,115,2,0,0,0,0,1,122,28,95,103,101,116,95, + 109,111,100,117,108,101,95,108,111,99,107,46,60,108,111,99, + 97,108,115,62,46,99,98,41,7,114,59,0,0,0,114,28, + 0,0,0,114,34,0,0,0,114,53,0,0,0,114,32,0, + 0,0,218,8,95,119,101,97,107,114,101,102,90,3,114,101, + 102,41,3,114,15,0,0,0,114,35,0,0,0,114,61,0, + 0,0,114,10,0,0,0,41,1,114,15,0,0,0,114,11, + 0,0,0,114,56,0,0,0,176,0,0,0,115,24,0,0, + 0,0,4,6,1,3,1,17,1,13,1,5,1,12,1,12, + 1,15,2,12,1,18,2,22,1,114,56,0,0,0,99,1, + 0,0,0,0,0,0,0,2,0,0,0,11,0,0,0,67, + 0,0,0,115,71,0,0,0,116,0,0,124,0,0,131,1, + 0,125,1,0,116,1,0,106,2,0,131,0,0,1,121,14, + 0,124,1,0,106,3,0,131,0,0,1,87,110,18,0,4, + 116,4,0,107,10,0,114,56,0,1,1,1,89,110,11,0, + 88,124,1,0,106,5,0,131,0,0,1,100,1,0,83,41, + 2,97,21,1,0,0,82,101,108,101,97,115,101,32,116,104, + 101,32,103,108,111,98,97,108,32,105,109,112,111,114,116,32, + 108,111,99,107,44,32,97,110,100,32,97,99,113,117,105,114, + 101,115,32,116,104,101,110,32,114,101,108,101,97,115,101,32, + 116,104,101,10,32,32,32,32,109,111,100,117,108,101,32,108, + 111,99,107,32,102,111,114,32,97,32,103,105,118,101,110,32, + 109,111,100,117,108,101,32,110,97,109,101,46,10,32,32,32, + 32,84,104,105,115,32,105,115,32,117,115,101,100,32,116,111, + 32,101,110,115,117,114,101,32,97,32,109,111,100,117,108,101, + 32,105,115,32,99,111,109,112,108,101,116,101,108,121,32,105, + 110,105,116,105,97,108,105,122,101,100,44,32,105,110,32,116, + 104,101,10,32,32,32,32,101,118,101,110,116,32,105,116,32, + 105,115,32,98,101,105,110,103,32,105,109,112,111,114,116,101, + 100,32,98,121,32,97,110,111,116,104,101,114,32,116,104,114, + 101,97,100,46,10,10,32,32,32,32,83,104,111,117,108,100, + 32,111,110,108,121,32,98,101,32,99,97,108,108,101,100,32, + 119,105,116,104,32,116,104,101,32,105,109,112,111,114,116,32, + 108,111,99,107,32,116,97,107,101,110,46,78,41,6,114,56, + 0,0,0,114,57,0,0,0,114,58,0,0,0,114,46,0, + 0,0,114,31,0,0,0,114,47,0,0,0,41,2,114,15, + 0,0,0,114,35,0,0,0,114,10,0,0,0,114,10,0, + 0,0,114,11,0,0,0,218,19,95,108,111,99,107,95,117, + 110,108,111,99,107,95,109,111,100,117,108,101,195,0,0,0, + 115,14,0,0,0,0,7,12,1,10,1,3,1,14,1,13, + 3,5,2,114,63,0,0,0,99,1,0,0,0,0,0,0, + 0,3,0,0,0,3,0,0,0,79,0,0,0,115,13,0, + 0,0,124,0,0,124,1,0,124,2,0,142,0,0,83,41, + 1,97,46,1,0,0,114,101,109,111,118,101,95,105,109,112, + 111,114,116,108,105,98,95,102,114,97,109,101,115,32,105,110, + 32,105,109,112,111,114,116,46,99,32,119,105,108,108,32,97, + 108,119,97,121,115,32,114,101,109,111,118,101,32,115,101,113, + 117,101,110,99,101,115,10,32,32,32,32,111,102,32,105,109, + 112,111,114,116,108,105,98,32,102,114,97,109,101,115,32,116, + 104,97,116,32,101,110,100,32,119,105,116,104,32,97,32,99, + 97,108,108,32,116,111,32,116,104,105,115,32,102,117,110,99, + 116,105,111,110,10,10,32,32,32,32,85,115,101,32,105,116, + 32,105,110,115,116,101,97,100,32,111,102,32,97,32,110,111, + 114,109,97,108,32,99,97,108,108,32,105,110,32,112,108,97, + 99,101,115,32,119,104,101,114,101,32,105,110,99,108,117,100, + 105,110,103,32,116,104,101,32,105,109,112,111,114,116,108,105, + 98,10,32,32,32,32,102,114,97,109,101,115,32,105,110,116, + 114,111,100,117,99,101,115,32,117,110,119,97,110,116,101,100, + 32,110,111,105,115,101,32,105,110,116,111,32,116,104,101,32, + 116,114,97,99,101,98,97,99,107,32,40,101,46,103,46,32, + 119,104,101,110,32,101,120,101,99,117,116,105,110,103,10,32, + 32,32,32,109,111,100,117,108,101,32,99,111,100,101,41,10, + 32,32,32,32,114,10,0,0,0,41,3,218,1,102,114,29, + 0,0,0,90,4,107,119,100,115,114,10,0,0,0,114,10, + 0,0,0,114,11,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,214,0,0,0,115,2,0,0,0,0,8,114,65, + 0,0,0,218,9,118,101,114,98,111,115,105,116,121,114,45, + 0,0,0,99,1,0,0,0,1,0,0,0,3,0,0,0, + 4,0,0,0,71,0,0,0,115,75,0,0,0,116,0,0, + 106,1,0,106,2,0,124,1,0,107,5,0,114,71,0,124, + 0,0,106,3,0,100,6,0,131,1,0,115,43,0,100,3, + 0,124,0,0,23,125,0,0,116,4,0,124,0,0,106,5, + 0,124,2,0,140,0,0,100,4,0,116,0,0,106,6,0, + 131,1,1,1,100,5,0,83,41,7,122,61,80,114,105,110, + 116,32,116,104,101,32,109,101,115,115,97,103,101,32,116,111, + 32,115,116,100,101,114,114,32,105,102,32,45,118,47,80,89, + 84,72,79,78,86,69,82,66,79,83,69,32,105,115,32,116, + 117,114,110,101,100,32,111,110,46,250,1,35,250,7,105,109, + 112,111,114,116,32,122,2,35,32,90,4,102,105,108,101,78, + 41,2,114,67,0,0,0,114,68,0,0,0,41,7,114,14, + 0,0,0,218,5,102,108,97,103,115,218,7,118,101,114,98, + 111,115,101,218,10,115,116,97,114,116,115,119,105,116,104,218, + 5,112,114,105,110,116,114,50,0,0,0,218,6,115,116,100, + 101,114,114,41,3,218,7,109,101,115,115,97,103,101,114,66, + 0,0,0,114,29,0,0,0,114,10,0,0,0,114,10,0, + 0,0,114,11,0,0,0,218,16,95,118,101,114,98,111,115, + 101,95,109,101,115,115,97,103,101,225,0,0,0,115,8,0, + 0,0,0,2,18,1,15,1,10,1,114,75,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,0,0,125,1,0,116,0,0,124,1, + 0,136,0,0,131,2,0,1,124,1,0,83,41,3,122,49, + 68,101,99,111,114,97,116,111,114,32,116,111,32,118,101,114, + 105,102,121,32,116,104,101,32,110,97,109,101,100,32,109,111, + 100,117,108,101,32,105,115,32,98,117,105,108,116,45,105,110, + 46,99,2,0,0,0,0,0,0,0,2,0,0,0,4,0, + 0,0,19,0,0,0,115,55,0,0,0,124,1,0,116,0, + 0,106,1,0,107,7,0,114,42,0,116,2,0,100,1,0, + 106,3,0,124,1,0,131,1,0,100,2,0,124,1,0,131, + 1,1,130,1,0,136,0,0,124,0,0,124,1,0,131,2, + 0,83,41,3,78,122,29,123,33,114,125,32,105,115,32,110, + 111,116,32,97,32,98,117,105,108,116,45,105,110,32,109,111, + 100,117,108,101,114,15,0,0,0,41,4,114,14,0,0,0, + 218,20,98,117,105,108,116,105,110,95,109,111,100,117,108,101, + 95,110,97,109,101,115,218,11,73,109,112,111,114,116,69,114, + 114,111,114,114,50,0,0,0,41,2,114,19,0,0,0,218, + 8,102,117,108,108,110,97,109,101,41,1,218,3,102,120,110, + 114,10,0,0,0,114,11,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,235,0,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,117,105, + 108,116,105,110,95,119,114,97,112,112,101,114,41,1,114,12, + 0,0,0,41,2,114,79,0,0,0,114,80,0,0,0,114, + 10,0,0,0,41,1,114,79,0,0,0,114,11,0,0,0, + 218,17,95,114,101,113,117,105,114,101,115,95,98,117,105,108, + 116,105,110,233,0,0,0,115,6,0,0,0,0,2,18,5, + 13,1,114,81,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,0,0, + 125,1,0,116,0,0,124,1,0,136,0,0,131,2,0,1, + 124,1,0,83,41,3,122,47,68,101,99,111,114,97,116,111, + 114,32,116,111,32,118,101,114,105,102,121,32,116,104,101,32, + 110,97,109,101,100,32,109,111,100,117,108,101,32,105,115,32, + 102,114,111,122,101,110,46,99,2,0,0,0,0,0,0,0, + 2,0,0,0,4,0,0,0,19,0,0,0,115,55,0,0, + 0,116,0,0,106,1,0,124,1,0,131,1,0,115,42,0, 116,2,0,100,1,0,106,3,0,124,1,0,131,1,0,100, - 2,0,124,1,0,131,1,1,130,1,0,110,0,0,136,0, - 0,124,0,0,124,1,0,131,2,0,83,41,3,78,122,29, - 123,33,114,125,32,105,115,32,110,111,116,32,97,32,98,117, - 105,108,116,45,105,110,32,109,111,100,117,108,101,114,67,0, - 0,0,41,4,114,7,0,0,0,218,20,98,117,105,108,116, - 105,110,95,109,111,100,117,108,101,95,110,97,109,101,115,114, - 154,0,0,0,114,47,0,0,0,41,2,114,71,0,0,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,34,2,0,0,115,8,0,0,0,0, - 1,15,1,18,1,12,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,117, - 105,108,116,105,110,95,119,114,97,112,112,101,114,41,1,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,32,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,0, - 0,125,1,0,116,0,0,124,1,0,136,0,0,131,2,0, - 1,124,1,0,83,41,3,122,47,68,101,99,111,114,97,116, - 111,114,32,116,111,32,118,101,114,105,102,121,32,116,104,101, - 32,110,97,109,101,100,32,109,111,100,117,108,101,32,105,115, - 32,102,114,111,122,101,110,46,99,2,0,0,0,0,0,0, - 0,2,0,0,0,4,0,0,0,19,0,0,0,115,58,0, - 0,0,116,0,0,106,1,0,124,1,0,131,1,0,115,45, - 0,116,2,0,100,1,0,106,3,0,124,1,0,131,1,0, - 100,2,0,124,1,0,131,1,1,130,1,0,110,0,0,136, - 0,0,124,0,0,124,1,0,131,2,0,83,41,3,78,122, - 27,123,33,114,125,32,105,115,32,110,111,116,32,97,32,102, - 114,111,122,101,110,32,109,111,100,117,108,101,114,67,0,0, - 0,41,4,114,106,0,0,0,218,9,105,115,95,102,114,111, - 122,101,110,114,154,0,0,0,114,47,0,0,0,41,2,114, - 71,0,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,45,2,0,0,115,8,0,0,0,0,1,15, - 1,18,1,12,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,43, - 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,87,0,0,0,124,0,0, - 106,0,0,124,1,0,131,1,0,92,2,0,125,2,0,125, - 3,0,124,2,0,100,1,0,107,8,0,114,83,0,116,1, - 0,124,3,0,131,1,0,114,83,0,100,2,0,125,4,0, - 116,2,0,106,3,0,124,4,0,106,4,0,124,3,0,100, - 3,0,25,131,1,0,116,5,0,131,2,0,1,110,0,0, - 124,2,0,83,41,4,122,155,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,32,98,121,32,100,101,108,101,103,97,116, - 105,110,103,32,116,111,10,32,32,32,32,115,101,108,102,46, - 102,105,110,100,95,108,111,97,100,101,114,40,41,46,10,10, - 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,32,105,110, - 32,102,97,118,111,114,32,111,102,32,102,105,110,100,101,114, - 46,102,105,110,100,95,115,112,101,99,40,41,46,10,10,32, - 32,32,32,78,122,44,78,111,116,32,105,109,112,111,114,116, - 105,110,103,32,100,105,114,101,99,116,111,114,121,32,123,125, - 58,32,109,105,115,115,105,110,103,32,95,95,105,110,105,116, - 95,95,114,84,0,0,0,41,6,218,11,102,105,110,100,95, - 108,111,97,100,101,114,114,31,0,0,0,218,9,95,119,97, - 114,110,105,110,103,115,218,4,119,97,114,110,114,47,0,0, - 0,218,13,73,109,112,111,114,116,87,97,114,110,105,110,103, - 41,5,114,71,0,0,0,114,159,0,0,0,218,6,108,111, - 97,100,101,114,218,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,54,2,0,0,115,10,0,0,0,0,10, - 21,1,24,1,6,1,32,1,114,173,0,0,0,99,2,0, - 0,0,0,0,0,0,5,0,0,0,3,0,0,0,67,0, - 0,0,115,93,0,0,0,116,0,0,124,1,0,124,0,0, - 131,2,0,125,2,0,116,1,0,124,2,0,131,1,0,125, - 3,0,124,1,0,116,2,0,106,3,0,107,6,0,114,79, - 0,116,2,0,106,3,0,124,1,0,25,125,4,0,124,3, - 0,106,4,0,124,4,0,131,1,0,1,116,2,0,106,3, - 0,124,1,0,25,83,124,3,0,106,5,0,131,0,0,83, - 100,1,0,83,41,2,122,128,76,111,97,100,32,116,104,101, - 32,115,112,101,99,105,102,105,101,100,32,109,111,100,117,108, - 101,32,105,110,116,111,32,115,121,115,46,109,111,100,117,108, - 101,115,32,97,110,100,32,114,101,116,117,114,110,32,105,116, - 46,10,10,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,108,111,97,100,101,114,46,101,120, - 101,99,95,109,111,100,117,108,101,32,105,110,115,116,101,97, - 100,46,10,10,32,32,32,32,78,41,6,218,16,115,112,101, - 99,95,102,114,111,109,95,108,111,97,100,101,114,218,12,95, - 83,112,101,99,77,101,116,104,111,100,115,114,7,0,0,0, - 114,73,0,0,0,218,4,101,120,101,99,218,4,108,111,97, - 100,41,5,114,71,0,0,0,114,159,0,0,0,218,4,115, - 112,101,99,218,7,109,101,116,104,111,100,115,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,71,2,0,0,115,14,0,0,0,0, - 6,15,1,12,1,15,1,13,1,13,1,11,2,114,181,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,255,1,0,0,105,0,0,125, - 4,0,124,2,0,100,1,0,107,9,0,114,31,0,124,2, - 0,124,4,0,100,2,0,60,110,6,0,100,3,0,125,2, - 0,124,3,0,100,1,0,107,9,0,114,62,0,124,3,0, - 124,4,0,100,4,0,60,110,0,0,124,0,0,100,1,0, - 100,5,0,133,2,0,25,125,5,0,124,0,0,100,5,0, - 100,6,0,133,2,0,25,125,6,0,124,0,0,100,6,0, - 100,7,0,133,2,0,25,125,7,0,124,5,0,116,0,0, - 107,3,0,114,171,0,100,8,0,106,1,0,124,2,0,124, - 5,0,131,2,0,125,8,0,116,2,0,100,9,0,124,8, - 0,131,2,0,1,116,3,0,124,8,0,124,4,0,141,1, - 0,130,1,0,110,122,0,116,4,0,124,6,0,131,1,0, - 100,5,0,107,3,0,114,232,0,100,10,0,106,1,0,124, - 2,0,131,1,0,125,8,0,116,2,0,100,9,0,124,8, - 0,131,2,0,1,116,5,0,124,8,0,131,1,0,130,1, - 0,110,61,0,116,4,0,124,7,0,131,1,0,100,5,0, - 107,3,0,114,37,1,100,11,0,106,1,0,124,2,0,131, - 1,0,125,8,0,116,2,0,100,9,0,124,8,0,131,2, - 0,1,116,5,0,124,8,0,131,1,0,130,1,0,110,0, - 0,124,1,0,100,1,0,107,9,0,114,241,1,121,20,0, - 116,6,0,124,1,0,100,12,0,25,131,1,0,125,9,0, - 87,110,18,0,4,116,7,0,107,10,0,114,89,1,1,1, - 1,89,110,65,0,88,116,8,0,124,6,0,131,1,0,124, - 9,0,107,3,0,114,154,1,100,13,0,106,1,0,124,2, - 0,131,1,0,125,8,0,116,2,0,100,9,0,124,8,0, - 131,2,0,1,116,3,0,124,8,0,124,4,0,141,1,0, - 130,1,0,110,0,0,121,18,0,124,1,0,100,14,0,25, - 100,15,0,64,125,10,0,87,110,18,0,4,116,7,0,107, - 10,0,114,192,1,1,1,1,89,113,241,1,88,116,8,0, - 124,7,0,131,1,0,124,10,0,107,3,0,114,241,1,116, - 3,0,100,13,0,106,1,0,124,2,0,131,1,0,124,4, - 0,141,1,0,130,1,0,113,241,1,110,0,0,124,0,0, - 100,7,0,100,1,0,133,2,0,25,83,41,16,97,122,1, - 0,0,86,97,108,105,100,97,116,101,32,116,104,101,32,104, - 101,97,100,101,114,32,111,102,32,116,104,101,32,112,97,115, - 115,101,100,45,105,110,32,98,121,116,101,99,111,100,101,32, - 97,103,97,105,110,115,116,32,115,111,117,114,99,101,95,115, - 116,97,116,115,32,40,105,102,10,32,32,32,32,103,105,118, - 101,110,41,32,97,110,100,32,114,101,116,117,114,110,105,110, - 103,32,116,104,101,32,98,121,116,101,99,111,100,101,32,116, - 104,97,116,32,99,97,110,32,98,101,32,99,111,109,112,105, - 108,101,100,32,98,121,32,99,111,109,112,105,108,101,40,41, - 46,10,10,32,32,32,32,65,108,108,32,111,116,104,101,114, - 32,97,114,103,117,109,101,110,116,115,32,97,114,101,32,117, - 115,101,100,32,116,111,32,101,110,104,97,110,99,101,32,101, - 114,114,111,114,32,114,101,112,111,114,116,105,110,103,46,10, - 10,32,32,32,32,73,109,112,111,114,116,69,114,114,111,114, - 32,105,115,32,114,97,105,115,101,100,32,119,104,101,110,32, - 116,104,101,32,109,97,103,105,99,32,110,117,109,98,101,114, - 32,105,115,32,105,110,99,111,114,114,101,99,116,32,111,114, - 32,116,104,101,32,98,121,116,101,99,111,100,101,32,105,115, - 10,32,32,32,32,102,111,117,110,100,32,116,111,32,98,101, - 32,115,116,97,108,101,46,32,69,79,70,69,114,114,111,114, - 32,105,115,32,114,97,105,115,101,100,32,119,104,101,110,32, - 116,104,101,32,100,97,116,97,32,105,115,32,102,111,117,110, - 100,32,116,111,32,98,101,10,32,32,32,32,116,114,117,110, - 99,97,116,101,100,46,10,10,32,32,32,32,78,114,67,0, - 0,0,122,10,60,98,121,116,101,99,111,100,101,62,114,35, - 0,0,0,114,12,0,0,0,233,8,0,0,0,233,12,0, - 0,0,122,30,98,97,100,32,109,97,103,105,99,32,110,117, - 109,98,101,114,32,105,110,32,123,33,114,125,58,32,123,33, - 114,125,122,2,123,125,122,43,114,101,97,99,104,101,100,32, - 69,79,70,32,119,104,105,108,101,32,114,101,97,100,105,110, - 103,32,116,105,109,101,115,116,97,109,112,32,105,110,32,123, - 33,114,125,122,48,114,101,97,99,104,101,100,32,69,79,70, - 32,119,104,105,108,101,32,114,101,97,100,105,110,103,32,115, - 105,122,101,32,111,102,32,115,111,117,114,99,101,32,105,110, - 32,123,33,114,125,218,5,109,116,105,109,101,122,26,98,121, - 116,101,99,111,100,101,32,105,115,32,115,116,97,108,101,32, - 102,111,114,32,123,33,114,125,218,4,115,105,122,101,108,3, - 0,0,0,255,127,255,127,3,0,41,9,218,12,77,65,71, - 73,67,95,78,85,77,66,69,82,114,47,0,0,0,114,153, - 0,0,0,114,154,0,0,0,114,31,0,0,0,218,8,69, - 79,70,69,114,114,111,114,114,14,0,0,0,114,79,0,0, - 0,114,19,0,0,0,41,11,114,53,0,0,0,218,12,115, - 111,117,114,99,101,95,115,116,97,116,115,114,67,0,0,0, - 114,35,0,0,0,90,11,101,120,99,95,100,101,116,97,105, - 108,115,90,5,109,97,103,105,99,90,13,114,97,119,95,116, - 105,109,101,115,116,97,109,112,90,8,114,97,119,95,115,105, - 122,101,114,152,0,0,0,218,12,115,111,117,114,99,101,95, - 109,116,105,109,101,218,11,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,87,2,0,0, - 115,76,0,0,0,0,11,6,1,12,1,13,3,6,1,12, - 1,13,1,16,1,16,1,16,1,12,1,18,1,13,1,18, - 1,18,1,15,1,13,1,15,1,18,1,15,1,13,1,15, - 1,12,1,3,1,20,1,13,1,5,2,18,1,15,1,13, - 1,18,1,3,1,18,1,13,1,5,2,18,1,15,1,15, - 1,114,191,0,0,0,99,4,0,0,0,0,0,0,0,5, - 0,0,0,6,0,0,0,67,0,0,0,115,115,0,0,0, - 116,0,0,106,1,0,124,0,0,131,1,0,125,4,0,116, - 2,0,124,4,0,116,3,0,131,2,0,114,78,0,116,4, - 0,100,1,0,124,2,0,131,2,0,1,124,3,0,100,2, - 0,107,9,0,114,74,0,116,5,0,106,6,0,124,4,0, - 124,3,0,131,2,0,1,110,0,0,124,4,0,83,116,7, - 0,100,3,0,106,8,0,124,2,0,131,1,0,100,4,0, - 124,1,0,100,5,0,124,2,0,131,1,2,130,1,0,100, - 2,0,83,41,6,122,60,67,111,109,112,105,108,101,32,98, - 121,116,101,99,111,100,101,32,97,115,32,114,101,116,117,114, - 110,101,100,32,98,121,32,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, - 40,41,46,122,21,99,111,100,101,32,111,98,106,101,99,116, - 32,102,114,111,109,32,123,33,114,125,78,122,23,78,111,110, - 45,99,111,100,101,32,111,98,106,101,99,116,32,105,110,32, - 123,33,114,125,114,67,0,0,0,114,35,0,0,0,41,9, - 218,7,109,97,114,115,104,97,108,90,5,108,111,97,100,115, - 218,10,105,115,105,110,115,116,97,110,99,101,218,10,95,99, - 111,100,101,95,116,121,112,101,114,153,0,0,0,114,106,0, - 0,0,90,16,95,102,105,120,95,99,111,95,102,105,108,101, - 110,97,109,101,114,154,0,0,0,114,47,0,0,0,41,5, - 114,53,0,0,0,114,67,0,0,0,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,142,2,0,0, - 115,16,0,0,0,0,2,15,1,15,1,13,1,12,1,19, - 1,4,2,18,1,114,196,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,0,0,116,1,0,131, - 1,0,125,3,0,124,3,0,106,2,0,116,3,0,124,1, - 0,131,1,0,131,1,0,1,124,3,0,106,2,0,116,3, - 0,124,2,0,131,1,0,131,1,0,1,124,3,0,106,2, - 0,116,4,0,106,5,0,124,0,0,131,1,0,131,1,0, - 1,124,3,0,83,41,1,122,80,67,111,109,112,105,108,101, - 32,97,32,99,111,100,101,32,111,98,106,101,99,116,32,105, - 110,116,111,32,98,121,116,101,99,111,100,101,32,102,111,114, - 32,119,114,105,116,105,110,103,32,111,117,116,32,116,111,32, - 97,32,98,121,116,101,45,99,111,109,112,105,108,101,100,10, - 32,32,32,32,102,105,108,101,46,41,6,218,9,98,121,116, - 101,97,114,114,97,121,114,186,0,0,0,218,6,101,120,116, - 101,110,100,114,17,0,0,0,114,192,0,0,0,90,5,100, - 117,109,112,115,41,4,114,195,0,0,0,114,184,0,0,0, - 114,190,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,154,2,0,0, - 115,10,0,0,0,0,3,12,1,19,1,19,1,22,1,114, - 199,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,116,1,0,106,2,0, - 124,0,0,131,1,0,106,3,0,125,2,0,124,1,0,106, - 4,0,124,2,0,131,1,0,125,3,0,116,1,0,106,5, - 0,100,2,0,100,3,0,131,2,0,125,4,0,124,4,0, - 106,6,0,124,0,0,106,6,0,124,3,0,100,1,0,25, - 131,1,0,131,1,0,83,41,4,122,121,68,101,99,111,100, - 101,32,98,121,116,101,115,32,114,101,112,114,101,115,101,110, - 116,105,110,103,32,115,111,117,114,99,101,32,99,111,100,101, - 32,97,110,100,32,114,101,116,117,114,110,32,116,104,101,32, - 115,116,114,105,110,103,46,10,10,32,32,32,32,85,110,105, - 118,101,114,115,97,108,32,110,101,119,108,105,110,101,32,115, - 117,112,112,111,114,116,32,105,115,32,117,115,101,100,32,105, - 110,32,116,104,101,32,100,101,99,111,100,105,110,103,46,10, - 32,32,32,32,114,84,0,0,0,78,84,41,7,218,8,116, - 111,107,101,110,105,122,101,114,49,0,0,0,90,7,66,121, - 116,101,115,73,79,90,8,114,101,97,100,108,105,110,101,90, - 15,100,101,116,101,99,116,95,101,110,99,111,100,105,110,103, - 90,25,73,110,99,114,101,109,101,110,116,97,108,78,101,119, - 108,105,110,101,68,101,99,111,100,101,114,218,6,100,101,99, - 111,100,101,41,5,218,12,115,111,117,114,99,101,95,98,121, - 116,101,115,114,200,0,0,0,90,21,115,111,117,114,99,101, - 95,98,121,116,101,115,95,114,101,97,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,164,2,0,0,115,10,0,0, - 0,0,5,12,1,18,1,15,1,18,1,114,204,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,15,1,0,0,116,0,0,124,0,0, - 100,1,0,100,0,0,131,3,0,125,1,0,116,1,0,124, - 1,0,100,2,0,131,2,0,114,74,0,121,17,0,124,1, - 0,106,2,0,124,0,0,131,1,0,83,87,113,74,0,4, - 116,3,0,107,10,0,114,70,0,1,1,1,89,113,74,0, - 88,110,0,0,121,13,0,124,0,0,106,4,0,125,2,0, - 87,110,18,0,4,116,5,0,107,10,0,114,107,0,1,1, - 1,89,110,29,0,88,124,2,0,100,0,0,107,9,0,114, - 136,0,116,6,0,124,2,0,131,1,0,106,2,0,131,0, - 0,83,121,13,0,124,0,0,106,7,0,125,3,0,87,110, - 24,0,4,116,5,0,107,10,0,114,175,0,1,1,1,100, - 3,0,125,3,0,89,110,1,0,88,121,13,0,124,0,0, - 106,8,0,125,4,0,87,110,59,0,4,116,5,0,107,10, - 0,114,250,0,1,1,1,124,1,0,100,0,0,107,8,0, - 114,230,0,100,4,0,106,9,0,124,3,0,131,1,0,83, - 100,5,0,106,9,0,124,3,0,124,1,0,131,2,0,83, - 89,110,17,0,88,100,6,0,106,9,0,124,3,0,124,4, - 0,131,2,0,83,100,0,0,83,41,7,78,218,10,95,95, - 108,111,97,100,101,114,95,95,218,11,109,111,100,117,108,101, - 95,114,101,112,114,250,1,63,122,13,60,109,111,100,117,108, - 101,32,123,33,114,125,62,122,20,60,109,111,100,117,108,101, - 32,123,33,114,125,32,40,123,33,114,125,41,62,122,23,60, - 109,111,100,117,108,101,32,123,33,114,125,32,102,114,111,109, - 32,123,33,114,125,62,41,10,114,62,0,0,0,114,60,0, - 0,0,114,206,0,0,0,218,9,69,120,99,101,112,116,105, - 111,110,218,8,95,95,115,112,101,99,95,95,218,14,65,116, - 116,114,105,98,117,116,101,69,114,114,111,114,114,175,0,0, - 0,114,57,0,0,0,218,8,95,95,102,105,108,101,95,95, - 114,47,0,0,0,41,5,114,180,0,0,0,114,170,0,0, - 0,114,178,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,178,2,0, - 0,115,46,0,0,0,0,2,18,1,15,4,3,1,17,1, - 13,1,8,1,3,1,13,1,13,1,5,2,12,1,16,4, - 3,1,13,1,13,1,11,1,3,1,13,1,13,1,12,1, - 13,2,21,2,114,212,0,0,0,99,0,0,0,0,0,0, - 0,0,0,0,0,0,2,0,0,0,64,0,0,0,115,52, - 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,100,3,0,100,4, - 0,132,0,0,90,4,0,100,5,0,100,6,0,132,0,0, - 90,5,0,100,7,0,83,41,8,218,17,95,105,110,115,116, - 97,108,108,101,100,95,115,97,102,101,108,121,99,2,0,0, - 0,0,0,0,0,2,0,0,0,2,0,0,0,67,0,0, - 0,115,25,0,0,0,124,1,0,124,0,0,95,0,0,124, - 1,0,106,1,0,124,0,0,95,2,0,100,0,0,83,41, - 1,78,41,3,218,7,95,109,111,100,117,108,101,114,209,0, - 0,0,218,5,95,115,112,101,99,41,2,114,71,0,0,0, - 114,180,0,0,0,114,4,0,0,0,114,4,0,0,0,114, - 5,0,0,0,114,72,0,0,0,216,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, - 0,0,0,67,0,0,0,115,38,0,0,0,100,1,0,124, - 0,0,106,0,0,95,1,0,124,0,0,106,2,0,116,3, - 0,106,4,0,124,0,0,106,0,0,106,5,0,60,100,0, - 0,83,41,2,78,84,41,6,114,215,0,0,0,218,13,95, - 105,110,105,116,105,97,108,105,122,105,110,103,114,214,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,220,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, - 0,0,17,0,0,0,71,0,0,0,115,121,0,0,0,122, - 101,0,124,0,0,106,0,0,125,2,0,116,1,0,100,1, - 0,100,2,0,132,0,0,124,1,0,68,131,1,0,131,1, - 0,114,78,0,121,17,0,116,2,0,106,3,0,124,2,0, - 106,4,0,61,87,113,100,0,4,116,5,0,107,10,0,114, - 74,0,1,1,1,89,113,100,0,88,110,22,0,116,6,0, - 100,3,0,124,2,0,106,4,0,124,2,0,106,7,0,131, - 3,0,1,87,100,0,0,100,4,0,124,0,0,106,0,0, - 95,8,0,88,100,0,0,83,41,5,78,99,1,0,0,0, - 0,0,0,0,2,0,0,0,3,0,0,0,115,0,0,0, - 115,27,0,0,0,124,0,0,93,17,0,125,1,0,124,1, - 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,230,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, - 114,62,122,18,105,109,112,111,114,116,32,123,33,114,125,32, - 35,32,123,33,114,125,70,41,9,114,215,0,0,0,114,78, - 0,0,0,114,7,0,0,0,114,73,0,0,0,114,67,0, - 0,0,114,79,0,0,0,114,153,0,0,0,114,170,0,0, - 0,114,216,0,0,0,41,3,114,71,0,0,0,114,80,0, - 0,0,114,178,0,0,0,114,4,0,0,0,114,4,0,0, - 0,114,5,0,0,0,114,81,0,0,0,227,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, + 2,0,124,1,0,131,1,1,130,1,0,136,0,0,124,0, + 0,124,1,0,131,2,0,83,41,3,78,122,27,123,33,114, + 125,32,105,115,32,110,111,116,32,97,32,102,114,111,122,101, + 110,32,109,111,100,117,108,101,114,15,0,0,0,41,4,114, + 57,0,0,0,218,9,105,115,95,102,114,111,122,101,110,114, + 77,0,0,0,114,50,0,0,0,41,2,114,19,0,0,0, + 114,78,0,0,0,41,1,114,79,0,0,0,114,10,0,0, + 0,114,11,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, + 246,0,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,12,0,0,0,41,2,114,79, + 0,0,0,114,83,0,0,0,114,10,0,0,0,41,1,114, + 79,0,0,0,114,11,0,0,0,218,16,95,114,101,113,117, + 105,114,101,115,95,102,114,111,122,101,110,244,0,0,0,115, + 6,0,0,0,0,2,18,5,13,1,114,84,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,0,124,1,0,116,1,0,106,2, + 0,107,6,0,114,67,0,116,1,0,106,2,0,124,1,0, + 25,125,3,0,116,3,0,124,2,0,124,3,0,131,2,0, + 1,116,1,0,106,2,0,124,1,0,25,83,116,4,0,124, + 2,0,131,1,0,83,100,1,0,83,41,2,122,128,76,111, + 97,100,32,116,104,101,32,115,112,101,99,105,102,105,101,100, + 32,109,111,100,117,108,101,32,105,110,116,111,32,115,121,115, + 46,109,111,100,117,108,101,115,32,97,110,100,32,114,101,116, + 117,114,110,32,105,116,46,10,10,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,108,111,97, + 100,101,114,46,101,120,101,99,95,109,111,100,117,108,101,32, + 105,110,115,116,101,97,100,46,10,10,32,32,32,32,78,41, + 5,218,16,115,112,101,99,95,102,114,111,109,95,108,111,97, + 100,101,114,114,14,0,0,0,114,21,0,0,0,218,5,95, + 101,120,101,99,218,5,95,108,111,97,100,41,4,114,19,0, + 0,0,114,78,0,0,0,218,4,115,112,101,99,218,6,109, + 111,100,117,108,101,114,10,0,0,0,114,10,0,0,0,114, + 11,0,0,0,218,17,95,108,111,97,100,95,109,111,100,117, + 108,101,95,115,104,105,109,0,1,0,0,115,12,0,0,0, + 0,6,15,1,15,1,13,1,13,1,11,2,114,90,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,116,0,0,124,0, + 0,100,1,0,100,0,0,131,3,0,125,1,0,116,1,0, + 124,1,0,100,2,0,131,2,0,114,71,0,121,17,0,124, + 1,0,106,2,0,124,0,0,131,1,0,83,87,110,18,0, + 4,116,3,0,107,10,0,114,70,0,1,1,1,89,110,1, + 0,88,121,13,0,124,0,0,106,4,0,125,2,0,87,110, + 18,0,4,116,5,0,107,10,0,114,104,0,1,1,1,89, + 110,23,0,88,124,2,0,100,0,0,107,9,0,114,127,0, + 116,6,0,124,2,0,131,1,0,83,121,13,0,124,0,0, + 106,7,0,125,3,0,87,110,24,0,4,116,5,0,107,10, + 0,114,166,0,1,1,1,100,3,0,125,3,0,89,110,1, + 0,88,121,13,0,124,0,0,106,8,0,125,4,0,87,110, + 59,0,4,116,5,0,107,10,0,114,241,0,1,1,1,124, + 1,0,100,0,0,107,8,0,114,221,0,100,4,0,106,9, + 0,124,3,0,131,1,0,83,100,5,0,106,9,0,124,3, + 0,124,1,0,131,2,0,83,89,110,17,0,88,100,6,0, + 106,9,0,124,3,0,124,4,0,131,2,0,83,100,0,0, + 83,41,7,78,218,10,95,95,108,111,97,100,101,114,95,95, + 218,11,109,111,100,117,108,101,95,114,101,112,114,250,1,63, + 122,13,60,109,111,100,117,108,101,32,123,33,114,125,62,122, + 20,60,109,111,100,117,108,101,32,123,33,114,125,32,40,123, + 33,114,125,41,62,122,23,60,109,111,100,117,108,101,32,123, + 33,114,125,32,102,114,111,109,32,123,33,114,125,62,41,10, + 114,6,0,0,0,114,4,0,0,0,114,92,0,0,0,218, + 9,69,120,99,101,112,116,105,111,110,218,8,95,95,115,112, + 101,99,95,95,218,14,65,116,116,114,105,98,117,116,101,69, + 114,114,111,114,218,22,95,109,111,100,117,108,101,95,114,101, + 112,114,95,102,114,111,109,95,115,112,101,99,114,1,0,0, + 0,218,8,95,95,102,105,108,101,95,95,114,50,0,0,0, + 41,5,114,89,0,0,0,218,6,108,111,97,100,101,114,114, + 88,0,0,0,114,15,0,0,0,218,8,102,105,108,101,110, + 97,109,101,114,10,0,0,0,114,10,0,0,0,114,11,0, + 0,0,218,12,95,109,111,100,117,108,101,95,114,101,112,114, + 16,1,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,13,2,21,2,114,101,0,0,0,99,0,0,0, + 0,0,0,0,0,0,0,0,0,2,0,0,0,64,0,0, + 0,115,52,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,100,3, + 0,100,4,0,132,0,0,90,4,0,100,5,0,100,6,0, + 132,0,0,90,5,0,100,7,0,83,41,8,218,17,95,105, + 110,115,116,97,108,108,101,100,95,115,97,102,101,108,121,99, + 2,0,0,0,0,0,0,0,2,0,0,0,2,0,0,0, + 67,0,0,0,115,25,0,0,0,124,1,0,124,0,0,95, + 0,0,124,1,0,106,1,0,124,0,0,95,2,0,100,0, + 0,83,41,1,78,41,3,218,7,95,109,111,100,117,108,101, + 114,95,0,0,0,218,5,95,115,112,101,99,41,2,114,19, + 0,0,0,114,89,0,0,0,114,10,0,0,0,114,10,0, + 0,0,114,11,0,0,0,114,20,0,0,0,54,1,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,0,0,0,67,0,0,0,115,38,0,0,0,100, + 1,0,124,0,0,106,0,0,95,1,0,124,0,0,106,2, + 0,116,3,0,106,4,0,124,0,0,106,0,0,106,5,0, + 60,100,0,0,83,41,2,78,84,41,6,114,104,0,0,0, + 218,13,95,105,110,105,116,105,97,108,105,122,105,110,103,114, + 103,0,0,0,114,14,0,0,0,114,21,0,0,0,114,15, + 0,0,0,41,1,114,19,0,0,0,114,10,0,0,0,114, + 10,0,0,0,114,11,0,0,0,114,23,0,0,0,58,1, + 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,0,0,17,0,0,0,71,0,0,0,115,121,0, + 0,0,122,101,0,124,0,0,106,0,0,125,2,0,116,1, + 0,100,1,0,100,2,0,132,0,0,124,1,0,68,131,1, + 0,131,1,0,114,78,0,121,17,0,116,2,0,106,3,0, + 124,2,0,106,4,0,61,87,113,100,0,4,116,5,0,107, + 10,0,114,74,0,1,1,1,89,113,100,0,88,110,22,0, + 116,6,0,100,3,0,124,2,0,106,4,0,124,2,0,106, + 7,0,131,3,0,1,87,100,0,0,100,4,0,124,0,0, + 106,0,0,95,8,0,88,100,0,0,83,41,5,78,99,1, + 0,0,0,0,0,0,0,2,0,0,0,3,0,0,0,115, + 0,0,0,115,27,0,0,0,124,0,0,93,17,0,125,1, + 0,124,1,0,100,0,0,107,9,0,86,1,113,3,0,100, + 0,0,83,41,1,78,114,10,0,0,0,41,2,114,24,0, + 0,0,114,25,0,0,0,114,10,0,0,0,114,10,0,0, + 0,114,11,0,0,0,114,26,0,0,0,68,1,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,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,213,0,0,0,214,2,0,0, - 115,6,0,0,0,12,2,12,4,12,7,114,213,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, - 100,0,0,90,2,0,100,1,0,90,3,0,100,2,0,100, - 3,0,100,4,0,100,3,0,100,5,0,100,3,0,100,6, - 0,100,7,0,132,0,3,90,4,0,100,8,0,100,9,0, - 132,0,0,90,5,0,100,10,0,100,11,0,132,0,0,90, - 6,0,101,7,0,100,12,0,100,13,0,132,0,0,131,1, - 0,90,8,0,101,8,0,106,9,0,100,14,0,100,13,0, - 132,0,0,131,1,0,90,8,0,101,7,0,100,15,0,100, - 16,0,132,0,0,131,1,0,90,10,0,101,7,0,100,17, - 0,100,18,0,132,0,0,131,1,0,90,11,0,101,11,0, - 106,9,0,100,19,0,100,18,0,132,0,0,131,1,0,90, - 11,0,100,3,0,83,41,20,218,10,77,111,100,117,108,101, - 83,112,101,99,97,208,5,0,0,84,104,101,32,115,112,101, - 99,105,102,105,99,97,116,105,111,110,32,102,111,114,32,97, - 32,109,111,100,117,108,101,44,32,117,115,101,100,32,102,111, - 114,32,108,111,97,100,105,110,103,46,10,10,32,32,32,32, - 65,32,109,111,100,117,108,101,39,115,32,115,112,101,99,32, - 105,115,32,116,104,101,32,115,111,117,114,99,101,32,102,111, - 114,32,105,110,102,111,114,109,97,116,105,111,110,32,97,98, - 111,117,116,32,116,104,101,32,109,111,100,117,108,101,46,32, - 32,70,111,114,10,32,32,32,32,100,97,116,97,32,97,115, - 115,111,99,105,97,116,101,100,32,119,105,116,104,32,116,104, - 101,32,109,111,100,117,108,101,44,32,105,110,99,108,117,100, - 105,110,103,32,115,111,117,114,99,101,44,32,117,115,101,32, - 116,104,101,32,115,112,101,99,39,115,10,32,32,32,32,108, - 111,97,100,101,114,46,10,10,32,32,32,32,96,110,97,109, - 101,96,32,105,115,32,116,104,101,32,97,98,115,111,108,117, - 116,101,32,110,97,109,101,32,111,102,32,116,104,101,32,109, - 111,100,117,108,101,46,32,32,96,108,111,97,100,101,114,96, - 32,105,115,32,116,104,101,32,108,111,97,100,101,114,10,32, - 32,32,32,116,111,32,117,115,101,32,119,104,101,110,32,108, - 111,97,100,105,110,103,32,116,104,101,32,109,111,100,117,108, - 101,46,32,32,96,112,97,114,101,110,116,96,32,105,115,32, - 116,104,101,32,110,97,109,101,32,111,102,32,116,104,101,10, - 32,32,32,32,112,97,99,107,97,103,101,32,116,104,101,32, - 109,111,100,117,108,101,32,105,115,32,105,110,46,32,32,84, - 104,101,32,112,97,114,101,110,116,32,105,115,32,100,101,114, - 105,118,101,100,32,102,114,111,109,32,116,104,101,32,110,97, - 109,101,46,10,10,32,32,32,32,96,105,115,95,112,97,99, - 107,97,103,101,96,32,100,101,116,101,114,109,105,110,101,115, - 32,105,102,32,116,104,101,32,109,111,100,117,108,101,32,105, - 115,32,99,111,110,115,105,100,101,114,101,100,32,97,32,112, - 97,99,107,97,103,101,32,111,114,10,32,32,32,32,110,111, - 116,46,32,32,79,110,32,109,111,100,117,108,101,115,32,116, - 104,105,115,32,105,115,32,114,101,102,108,101,99,116,101,100, - 32,98,121,32,116,104,101,32,96,95,95,112,97,116,104,95, - 95,96,32,97,116,116,114,105,98,117,116,101,46,10,10,32, - 32,32,32,96,111,114,105,103,105,110,96,32,105,115,32,116, - 104,101,32,115,112,101,99,105,102,105,99,32,108,111,99,97, - 116,105,111,110,32,117,115,101,100,32,98,121,32,116,104,101, - 32,108,111,97,100,101,114,32,102,114,111,109,32,119,104,105, - 99,104,32,116,111,10,32,32,32,32,108,111,97,100,32,116, - 104,101,32,109,111,100,117,108,101,44,32,105,102,32,116,104, - 97,116,32,105,110,102,111,114,109,97,116,105,111,110,32,105, - 115,32,97,118,97,105,108,97,98,108,101,46,32,32,87,104, - 101,110,32,102,105,108,101,110,97,109,101,32,105,115,10,32, - 32,32,32,115,101,116,44,32,111,114,105,103,105,110,32,119, - 105,108,108,32,109,97,116,99,104,46,10,10,32,32,32,32, - 96,104,97,115,95,108,111,99,97,116,105,111,110,96,32,105, - 110,100,105,99,97,116,101,115,32,116,104,97,116,32,97,32, - 115,112,101,99,39,115,32,34,111,114,105,103,105,110,34,32, - 114,101,102,108,101,99,116,115,32,97,32,108,111,99,97,116, - 105,111,110,46,10,32,32,32,32,87,104,101,110,32,116,104, - 105,115,32,105,115,32,84,114,117,101,44,32,96,95,95,102, - 105,108,101,95,95,96,32,97,116,116,114,105,98,117,116,101, - 32,111,102,32,116,104,101,32,109,111,100,117,108,101,32,105, - 115,32,115,101,116,46,10,10,32,32,32,32,96,99,97,99, - 104,101,100,96,32,105,115,32,116,104,101,32,108,111,99,97, - 116,105,111,110,32,111,102,32,116,104,101,32,99,97,99,104, - 101,100,32,98,121,116,101,99,111,100,101,32,102,105,108,101, - 44,32,105,102,32,97,110,121,46,32,32,73,116,10,32,32, - 32,32,99,111,114,114,101,115,112,111,110,100,115,32,116,111, - 32,116,104,101,32,96,95,95,99,97,99,104,101,100,95,95, - 96,32,97,116,116,114,105,98,117,116,101,46,10,10,32,32, - 32,32,96,115,117,98,109,111,100,117,108,101,95,115,101,97, - 114,99,104,95,108,111,99,97,116,105,111,110,115,96,32,105, - 115,32,116,104,101,32,115,101,113,117,101,110,99,101,32,111, - 102,32,112,97,116,104,32,101,110,116,114,105,101,115,32,116, - 111,10,32,32,32,32,115,101,97,114,99,104,32,119,104,101, - 110,32,105,109,112,111,114,116,105,110,103,32,115,117,98,109, - 111,100,117,108,101,115,46,32,32,73,102,32,115,101,116,44, - 32,105,115,95,112,97,99,107,97,103,101,32,115,104,111,117, - 108,100,32,98,101,10,32,32,32,32,84,114,117,101,45,45, - 97,110,100,32,70,97,108,115,101,32,111,116,104,101,114,119, - 105,115,101,46,10,10,32,32,32,32,80,97,99,107,97,103, - 101,115,32,97,114,101,32,115,105,109,112,108,121,32,109,111, - 100,117,108,101,115,32,116,104,97,116,32,40,109,97,121,41, - 32,104,97,118,101,32,115,117,98,109,111,100,117,108,101,115, - 46,32,32,73,102,32,97,32,115,112,101,99,10,32,32,32, - 32,104,97,115,32,97,32,110,111,110,45,78,111,110,101,32, - 118,97,108,117,101,32,105,110,32,96,115,117,98,109,111,100, - 117,108,101,95,115,101,97,114,99,104,95,108,111,99,97,116, - 105,111,110,115,96,44,32,116,104,101,32,105,109,112,111,114, - 116,10,32,32,32,32,115,121,115,116,101,109,32,119,105,108, - 108,32,99,111,110,115,105,100,101,114,32,109,111,100,117,108, - 101,115,32,108,111,97,100,101,100,32,102,114,111,109,32,116, - 104,101,32,115,112,101,99,32,97,115,32,112,97,99,107,97, - 103,101,115,46,10,10,32,32,32,32,79,110,108,121,32,102, - 105,110,100,101,114,115,32,40,115,101,101,32,105,109,112,111, - 114,116,108,105,98,46,97,98,99,46,77,101,116,97,80,97, - 116,104,70,105,110,100,101,114,32,97,110,100,10,32,32,32, - 32,105,109,112,111,114,116,108,105,98,46,97,98,99,46,80, - 97,116,104,69,110,116,114,121,70,105,110,100,101,114,41,32, - 115,104,111,117,108,100,32,109,111,100,105,102,121,32,77,111, - 100,117,108,101,83,112,101,99,32,105,110,115,116,97,110,99, - 101,115,46,10,10,32,32,32,32,218,6,111,114,105,103,105, - 110,78,218,12,108,111,97,100,101,114,95,115,116,97,116,101, - 218,10,105,115,95,112,97,99,107,97,103,101,99,3,0,0, - 0,3,0,0,0,6,0,0,0,2,0,0,0,67,0,0, - 0,115,79,0,0,0,124,1,0,124,0,0,95,0,0,124, - 2,0,124,0,0,95,1,0,124,3,0,124,0,0,95,2, - 0,124,4,0,124,0,0,95,3,0,124,5,0,114,48,0, - 103,0,0,110,3,0,100,0,0,124,0,0,95,4,0,100, - 1,0,124,0,0,95,5,0,100,0,0,124,0,0,95,6, - 0,100,0,0,83,41,2,78,70,41,7,114,67,0,0,0, - 114,170,0,0,0,114,218,0,0,0,114,219,0,0,0,218, - 26,115,117,98,109,111,100,117,108,101,95,115,101,97,114,99, - 104,95,108,111,99,97,116,105,111,110,115,218,13,95,115,101, - 116,95,102,105,108,101,97,116,116,114,218,7,95,99,97,99, - 104,101,100,41,6,114,71,0,0,0,114,67,0,0,0,114, - 170,0,0,0,114,218,0,0,0,114,219,0,0,0,114,220, - 0,0,0,114,4,0,0,0,114,4,0,0,0,114,5,0, - 0,0,114,72,0,0,0,22,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, - 4,0,0,0,67,0,0,0,115,153,0,0,0,100,1,0, - 106,0,0,124,0,0,106,1,0,131,1,0,100,2,0,106, - 0,0,124,0,0,106,2,0,131,1,0,103,2,0,125,1, - 0,124,0,0,106,3,0,100,0,0,107,9,0,114,79,0, - 124,1,0,106,4,0,100,3,0,106,0,0,124,0,0,106, - 3,0,131,1,0,131,1,0,1,110,0,0,124,0,0,106, - 5,0,100,0,0,107,9,0,114,122,0,124,1,0,106,4, + 95,95,46,60,108,111,99,97,108,115,62,46,60,103,101,110, + 101,120,112,114,62,122,18,105,109,112,111,114,116,32,123,33, + 114,125,32,35,32,123,33,114,125,70,41,9,114,104,0,0, + 0,114,27,0,0,0,114,14,0,0,0,114,21,0,0,0, + 114,15,0,0,0,114,28,0,0,0,114,75,0,0,0,114, + 99,0,0,0,114,105,0,0,0,41,3,114,19,0,0,0, + 114,29,0,0,0,114,88,0,0,0,114,10,0,0,0,114, + 10,0,0,0,114,11,0,0,0,114,30,0,0,0,65,1, + 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,1,0,0,0,114,0,0, + 0,0,114,2,0,0,0,114,20,0,0,0,114,23,0,0, + 0,114,30,0,0,0,114,10,0,0,0,114,10,0,0,0, + 114,10,0,0,0,114,11,0,0,0,114,102,0,0,0,52, + 1,0,0,115,6,0,0,0,12,2,12,4,12,7,114,102, + 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,100,0,0,90,2,0,100,1,0,90,3,0,100, + 2,0,100,3,0,100,4,0,100,3,0,100,5,0,100,3, + 0,100,6,0,100,7,0,132,0,3,90,4,0,100,8,0, + 100,9,0,132,0,0,90,5,0,100,10,0,100,11,0,132, + 0,0,90,6,0,101,7,0,100,12,0,100,13,0,132,0, + 0,131,1,0,90,8,0,101,8,0,106,9,0,100,14,0, + 100,13,0,132,0,0,131,1,0,90,8,0,101,7,0,100, + 15,0,100,16,0,132,0,0,131,1,0,90,10,0,101,7, + 0,100,17,0,100,18,0,132,0,0,131,1,0,90,11,0, + 101,11,0,106,9,0,100,19,0,100,18,0,132,0,0,131, + 1,0,90,11,0,100,3,0,83,41,20,218,10,77,111,100, + 117,108,101,83,112,101,99,97,208,5,0,0,84,104,101,32, + 115,112,101,99,105,102,105,99,97,116,105,111,110,32,102,111, + 114,32,97,32,109,111,100,117,108,101,44,32,117,115,101,100, + 32,102,111,114,32,108,111,97,100,105,110,103,46,10,10,32, + 32,32,32,65,32,109,111,100,117,108,101,39,115,32,115,112, + 101,99,32,105,115,32,116,104,101,32,115,111,117,114,99,101, + 32,102,111,114,32,105,110,102,111,114,109,97,116,105,111,110, + 32,97,98,111,117,116,32,116,104,101,32,109,111,100,117,108, + 101,46,32,32,70,111,114,10,32,32,32,32,100,97,116,97, + 32,97,115,115,111,99,105,97,116,101,100,32,119,105,116,104, + 32,116,104,101,32,109,111,100,117,108,101,44,32,105,110,99, + 108,117,100,105,110,103,32,115,111,117,114,99,101,44,32,117, + 115,101,32,116,104,101,32,115,112,101,99,39,115,10,32,32, + 32,32,108,111,97,100,101,114,46,10,10,32,32,32,32,96, + 110,97,109,101,96,32,105,115,32,116,104,101,32,97,98,115, + 111,108,117,116,101,32,110,97,109,101,32,111,102,32,116,104, + 101,32,109,111,100,117,108,101,46,32,32,96,108,111,97,100, + 101,114,96,32,105,115,32,116,104,101,32,108,111,97,100,101, + 114,10,32,32,32,32,116,111,32,117,115,101,32,119,104,101, + 110,32,108,111,97,100,105,110,103,32,116,104,101,32,109,111, + 100,117,108,101,46,32,32,96,112,97,114,101,110,116,96,32, + 105,115,32,116,104,101,32,110,97,109,101,32,111,102,32,116, + 104,101,10,32,32,32,32,112,97,99,107,97,103,101,32,116, + 104,101,32,109,111,100,117,108,101,32,105,115,32,105,110,46, + 32,32,84,104,101,32,112,97,114,101,110,116,32,105,115,32, + 100,101,114,105,118,101,100,32,102,114,111,109,32,116,104,101, + 32,110,97,109,101,46,10,10,32,32,32,32,96,105,115,95, + 112,97,99,107,97,103,101,96,32,100,101,116,101,114,109,105, + 110,101,115,32,105,102,32,116,104,101,32,109,111,100,117,108, + 101,32,105,115,32,99,111,110,115,105,100,101,114,101,100,32, + 97,32,112,97,99,107,97,103,101,32,111,114,10,32,32,32, + 32,110,111,116,46,32,32,79,110,32,109,111,100,117,108,101, + 115,32,116,104,105,115,32,105,115,32,114,101,102,108,101,99, + 116,101,100,32,98,121,32,116,104,101,32,96,95,95,112,97, + 116,104,95,95,96,32,97,116,116,114,105,98,117,116,101,46, + 10,10,32,32,32,32,96,111,114,105,103,105,110,96,32,105, + 115,32,116,104,101,32,115,112,101,99,105,102,105,99,32,108, + 111,99,97,116,105,111,110,32,117,115,101,100,32,98,121,32, + 116,104,101,32,108,111,97,100,101,114,32,102,114,111,109,32, + 119,104,105,99,104,32,116,111,10,32,32,32,32,108,111,97, + 100,32,116,104,101,32,109,111,100,117,108,101,44,32,105,102, + 32,116,104,97,116,32,105,110,102,111,114,109,97,116,105,111, + 110,32,105,115,32,97,118,97,105,108,97,98,108,101,46,32, + 32,87,104,101,110,32,102,105,108,101,110,97,109,101,32,105, + 115,10,32,32,32,32,115,101,116,44,32,111,114,105,103,105, + 110,32,119,105,108,108,32,109,97,116,99,104,46,10,10,32, + 32,32,32,96,104,97,115,95,108,111,99,97,116,105,111,110, + 96,32,105,110,100,105,99,97,116,101,115,32,116,104,97,116, + 32,97,32,115,112,101,99,39,115,32,34,111,114,105,103,105, + 110,34,32,114,101,102,108,101,99,116,115,32,97,32,108,111, + 99,97,116,105,111,110,46,10,32,32,32,32,87,104,101,110, + 32,116,104,105,115,32,105,115,32,84,114,117,101,44,32,96, + 95,95,102,105,108,101,95,95,96,32,97,116,116,114,105,98, + 117,116,101,32,111,102,32,116,104,101,32,109,111,100,117,108, + 101,32,105,115,32,115,101,116,46,10,10,32,32,32,32,96, + 99,97,99,104,101,100,96,32,105,115,32,116,104,101,32,108, + 111,99,97,116,105,111,110,32,111,102,32,116,104,101,32,99, + 97,99,104,101,100,32,98,121,116,101,99,111,100,101,32,102, + 105,108,101,44,32,105,102,32,97,110,121,46,32,32,73,116, + 10,32,32,32,32,99,111,114,114,101,115,112,111,110,100,115, + 32,116,111,32,116,104,101,32,96,95,95,99,97,99,104,101, + 100,95,95,96,32,97,116,116,114,105,98,117,116,101,46,10, + 10,32,32,32,32,96,115,117,98,109,111,100,117,108,101,95, + 115,101,97,114,99,104,95,108,111,99,97,116,105,111,110,115, + 96,32,105,115,32,116,104,101,32,115,101,113,117,101,110,99, + 101,32,111,102,32,112,97,116,104,32,101,110,116,114,105,101, + 115,32,116,111,10,32,32,32,32,115,101,97,114,99,104,32, + 119,104,101,110,32,105,109,112,111,114,116,105,110,103,32,115, + 117,98,109,111,100,117,108,101,115,46,32,32,73,102,32,115, + 101,116,44,32,105,115,95,112,97,99,107,97,103,101,32,115, + 104,111,117,108,100,32,98,101,10,32,32,32,32,84,114,117, + 101,45,45,97,110,100,32,70,97,108,115,101,32,111,116,104, + 101,114,119,105,115,101,46,10,10,32,32,32,32,80,97,99, + 107,97,103,101,115,32,97,114,101,32,115,105,109,112,108,121, + 32,109,111,100,117,108,101,115,32,116,104,97,116,32,40,109, + 97,121,41,32,104,97,118,101,32,115,117,98,109,111,100,117, + 108,101,115,46,32,32,73,102,32,97,32,115,112,101,99,10, + 32,32,32,32,104,97,115,32,97,32,110,111,110,45,78,111, + 110,101,32,118,97,108,117,101,32,105,110,32,96,115,117,98, + 109,111,100,117,108,101,95,115,101,97,114,99,104,95,108,111, + 99,97,116,105,111,110,115,96,44,32,116,104,101,32,105,109, + 112,111,114,116,10,32,32,32,32,115,121,115,116,101,109,32, + 119,105,108,108,32,99,111,110,115,105,100,101,114,32,109,111, + 100,117,108,101,115,32,108,111,97,100,101,100,32,102,114,111, + 109,32,116,104,101,32,115,112,101,99,32,97,115,32,112,97, + 99,107,97,103,101,115,46,10,10,32,32,32,32,79,110,108, + 121,32,102,105,110,100,101,114,115,32,40,115,101,101,32,105, + 109,112,111,114,116,108,105,98,46,97,98,99,46,77,101,116, + 97,80,97,116,104,70,105,110,100,101,114,32,97,110,100,10, + 32,32,32,32,105,109,112,111,114,116,108,105,98,46,97,98, + 99,46,80,97,116,104,69,110,116,114,121,70,105,110,100,101, + 114,41,32,115,104,111,117,108,100,32,109,111,100,105,102,121, + 32,77,111,100,117,108,101,83,112,101,99,32,105,110,115,116, + 97,110,99,101,115,46,10,10,32,32,32,32,218,6,111,114, + 105,103,105,110,78,218,12,108,111,97,100,101,114,95,115,116, + 97,116,101,218,10,105,115,95,112,97,99,107,97,103,101,99, + 3,0,0,0,3,0,0,0,6,0,0,0,2,0,0,0, + 67,0,0,0,115,79,0,0,0,124,1,0,124,0,0,95, + 0,0,124,2,0,124,0,0,95,1,0,124,3,0,124,0, + 0,95,2,0,124,4,0,124,0,0,95,3,0,124,5,0, + 114,48,0,103,0,0,110,3,0,100,0,0,124,0,0,95, + 4,0,100,1,0,124,0,0,95,5,0,100,0,0,124,0, + 0,95,6,0,100,0,0,83,41,2,78,70,41,7,114,15, + 0,0,0,114,99,0,0,0,114,107,0,0,0,114,108,0, + 0,0,218,26,115,117,98,109,111,100,117,108,101,95,115,101, + 97,114,99,104,95,108,111,99,97,116,105,111,110,115,218,13, + 95,115,101,116,95,102,105,108,101,97,116,116,114,218,7,95, + 99,97,99,104,101,100,41,6,114,19,0,0,0,114,15,0, + 0,0,114,99,0,0,0,114,107,0,0,0,114,108,0,0, + 0,114,109,0,0,0,114,10,0,0,0,114,10,0,0,0, + 114,11,0,0,0,114,20,0,0,0,116,1,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,4,0,0,0,67,0,0,0,115,147,0,0,0, + 100,1,0,106,0,0,124,0,0,106,1,0,131,1,0,100, + 2,0,106,0,0,124,0,0,106,2,0,131,1,0,103,2, + 0,125,1,0,124,0,0,106,3,0,100,0,0,107,9,0, + 114,76,0,124,1,0,106,4,0,100,3,0,106,0,0,124, + 0,0,106,3,0,131,1,0,131,1,0,1,124,0,0,106, + 5,0,100,0,0,107,9,0,114,116,0,124,1,0,106,4, 0,100,4,0,106,0,0,124,0,0,106,5,0,131,1,0, - 131,1,0,1,110,0,0,100,5,0,106,0,0,124,0,0, - 106,6,0,106,7,0,100,6,0,106,8,0,124,1,0,131, - 1,0,131,2,0,83,41,7,78,122,9,110,97,109,101,61, - 123,33,114,125,122,11,108,111,97,100,101,114,61,123,33,114, - 125,122,11,111,114,105,103,105,110,61,123,33,114,125,122,29, - 115,117,98,109,111,100,117,108,101,95,115,101,97,114,99,104, - 95,108,111,99,97,116,105,111,110,115,61,123,125,122,6,123, - 125,40,123,125,41,122,2,44,32,41,9,114,47,0,0,0, - 114,67,0,0,0,114,170,0,0,0,114,218,0,0,0,218, - 6,97,112,112,101,110,100,114,221,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,34,3,0,0,115,16,0,0,0,0,1,15,1,21,1, - 15,1,28,1,15,1,12,1,16,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,0,0,3,0,0,0,11,0,0,0, - 67,0,0,0,115,145,0,0,0,124,0,0,106,0,0,125, - 2,0,121,107,0,124,0,0,106,1,0,124,1,0,106,1, - 0,107,2,0,111,114,0,124,0,0,106,2,0,124,1,0, - 106,2,0,107,2,0,111,114,0,124,0,0,106,3,0,124, - 1,0,106,3,0,107,2,0,111,114,0,124,2,0,124,1, - 0,106,0,0,107,2,0,111,114,0,124,0,0,106,4,0, - 124,1,0,106,4,0,107,2,0,111,114,0,124,0,0,106, - 5,0,124,1,0,106,5,0,107,2,0,83,87,110,22,0, - 4,116,6,0,107,10,0,114,140,0,1,1,1,100,1,0, - 83,89,110,1,0,88,100,0,0,83,41,2,78,70,41,7, - 114,221,0,0,0,114,67,0,0,0,114,170,0,0,0,114, - 218,0,0,0,218,6,99,97,99,104,101,100,218,12,104,97, - 115,95,108,111,99,97,116,105,111,110,114,210,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,44,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,0,11,0,0,0,67,0,0,0,115, - 158,0,0,0,124,0,0,106,0,0,100,0,0,107,8,0, - 114,151,0,124,0,0,106,1,0,100,0,0,107,9,0,114, - 151,0,124,0,0,106,2,0,114,151,0,124,0,0,106,1, - 0,125,1,0,124,1,0,106,3,0,116,4,0,116,5,0, - 131,1,0,131,1,0,114,112,0,121,19,0,116,6,0,124, - 1,0,131,1,0,124,0,0,95,0,0,87,113,145,0,4, - 116,7,0,107,10,0,114,108,0,1,1,1,89,113,145,0, - 88,113,148,0,124,1,0,106,3,0,116,4,0,116,8,0, - 131,1,0,131,1,0,114,148,0,124,1,0,124,0,0,95, - 0,0,113,148,0,113,151,0,110,0,0,124,0,0,106,0, - 0,83,41,1,78,41,9,114,223,0,0,0,114,218,0,0, - 0,114,222,0,0,0,218,8,101,110,100,115,119,105,116,104, - 218,5,116,117,112,108,101,114,135,0,0,0,114,132,0,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,226,0,0,0,56,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,18,1,122,17,77,111,100,117,108,101, - 83,112,101,99,46,99,97,99,104,101,100,99,2,0,0,0, - 0,0,0,0,2,0,0,0,2,0,0,0,67,0,0,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,223,0,0,0,41,2,114,71, - 0,0,0,114,226,0,0,0,114,4,0,0,0,114,4,0, - 0,0,114,5,0,0,0,114,226,0,0,0,70,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,0, - 124,0,0,106,1,0,106,2,0,100,2,0,131,1,0,100, - 3,0,25,83,124,0,0,106,1,0,83,100,1,0,83,41, - 4,122,32,84,104,101,32,110,97,109,101,32,111,102,32,116, - 104,101,32,109,111,100,117,108,101,39,115,32,112,97,114,101, - 110,116,46,78,114,116,0,0,0,114,84,0,0,0,41,3, - 114,221,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,74,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,222,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,227,0,0,0,82,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,19, - 0,0,0,116,0,0,124,1,0,131,1,0,124,0,0,95, - 1,0,100,0,0,83,41,1,78,41,2,218,4,98,111,111, - 108,114,222,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,227,0,0,0,86,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,230,0,0,0,218,8,112,114,111,112,101,114, - 116,121,114,226,0,0,0,218,6,115,101,116,116,101,114,114, - 234,0,0,0,114,227,0,0,0,114,4,0,0,0,114,4, - 0,0,0,114,4,0,0,0,114,5,0,0,0,114,217,0, - 0,0,241,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, - 217,0,0,0,114,218,0,0,0,114,220,0,0,0,99,2, - 0,0,0,2,0,0,0,5,0,0,0,15,0,0,0,67, - 0,0,0,115,193,0,0,0,116,0,0,124,1,0,100,1, - 0,131,2,0,114,83,0,124,3,0,100,2,0,107,8,0, - 114,43,0,116,1,0,124,0,0,100,3,0,124,1,0,131, - 1,1,83,124,3,0,114,55,0,103,0,0,110,3,0,100, - 2,0,125,4,0,116,1,0,124,0,0,100,3,0,124,1, - 0,100,4,0,124,4,0,131,1,2,83,124,3,0,100,2, - 0,107,8,0,114,168,0,116,0,0,124,1,0,100,5,0, - 131,2,0,114,159,0,121,19,0,124,1,0,106,2,0,124, - 0,0,131,1,0,125,3,0,87,113,165,0,4,116,3,0, - 107,10,0,114,155,0,1,1,1,100,2,0,125,3,0,89, - 113,165,0,88,113,168,0,100,6,0,125,3,0,110,0,0, - 116,4,0,124,0,0,124,1,0,100,7,0,124,2,0,100, - 5,0,124,3,0,131,2,2,83,41,8,122,53,82,101,116, - 117,114,110,32,97,32,109,111,100,117,108,101,32,115,112,101, - 99,32,98,97,115,101,100,32,111,110,32,118,97,114,105,111, - 117,115,32,108,111,97,100,101,114,32,109,101,116,104,111,100, - 115,46,218,12,103,101,116,95,102,105,108,101,110,97,109,101, - 78,114,170,0,0,0,114,221,0,0,0,114,220,0,0,0, - 70,114,218,0,0,0,41,5,114,60,0,0,0,218,23,115, - 112,101,99,95,102,114,111,109,95,102,105,108,101,95,108,111, - 99,97,116,105,111,110,114,220,0,0,0,114,154,0,0,0, - 114,217,0,0,0,41,5,114,67,0,0,0,114,170,0,0, - 0,114,218,0,0,0,114,220,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,91,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,9,2,114,174,0,0, - 0,114,170,0,0,0,114,221,0,0,0,99,2,0,0,0, - 2,0,0,0,9,0,0,0,19,0,0,0,67,0,0,0, - 115,110,1,0,0,124,1,0,100,1,0,107,8,0,114,79, - 0,100,2,0,125,1,0,116,0,0,124,2,0,100,3,0, - 131,2,0,114,79,0,121,19,0,124,2,0,106,1,0,124, - 0,0,131,1,0,125,1,0,87,113,76,0,4,116,2,0, - 107,10,0,114,72,0,1,1,1,89,113,76,0,88,113,79, - 0,110,0,0,116,3,0,124,0,0,124,2,0,100,4,0, - 124,1,0,131,2,1,125,4,0,100,5,0,124,4,0,95, - 4,0,124,2,0,100,1,0,107,8,0,114,203,0,120,79, - 0,116,5,0,131,0,0,68,93,61,0,92,2,0,125,5, - 0,125,6,0,124,1,0,106,6,0,116,7,0,124,6,0, - 131,1,0,131,1,0,114,131,0,124,5,0,124,0,0,124, - 1,0,131,2,0,125,2,0,124,2,0,124,4,0,95,8, - 0,80,113,131,0,113,131,0,87,100,1,0,83,110,0,0, - 124,3,0,116,9,0,107,8,0,114,38,1,116,0,0,124, - 2,0,100,6,0,131,2,0,114,47,1,121,19,0,124,2, - 0,106,10,0,124,0,0,131,1,0,125,7,0,87,110,18, - 0,4,116,2,0,107,10,0,114,13,1,1,1,1,89,113, - 35,1,88,124,7,0,114,35,1,103,0,0,124,4,0,95, - 11,0,113,35,1,113,47,1,110,9,0,124,3,0,124,4, - 0,95,11,0,124,4,0,106,11,0,103,0,0,107,2,0, - 114,106,1,124,1,0,114,106,1,116,12,0,124,1,0,131, - 1,0,100,7,0,25,125,8,0,124,4,0,106,11,0,106, - 13,0,124,8,0,131,1,0,1,113,106,1,110,0,0,124, - 4,0,83,41,8,97,61,1,0,0,82,101,116,117,114,110, - 32,97,32,109,111,100,117,108,101,32,115,112,101,99,32,98, - 97,115,101,100,32,111,110,32,97,32,102,105,108,101,32,108, - 111,99,97,116,105,111,110,46,10,10,32,32,32,32,84,111, - 32,105,110,100,105,99,97,116,101,32,116,104,97,116,32,116, - 104,101,32,109,111,100,117,108,101,32,105,115,32,97,32,112, - 97,99,107,97,103,101,44,32,115,101,116,10,32,32,32,32, - 115,117,98,109,111,100,117,108,101,95,115,101,97,114,99,104, - 95,108,111,99,97,116,105,111,110,115,32,116,111,32,97,32, - 108,105,115,116,32,111,102,32,100,105,114,101,99,116,111,114, - 121,32,112,97,116,104,115,46,32,32,65,110,10,32,32,32, - 32,101,109,112,116,121,32,108,105,115,116,32,105,115,32,115, - 117,102,102,105,99,105,101,110,116,44,32,116,104,111,117,103, - 104,32,105,116,115,32,110,111,116,32,111,116,104,101,114,119, - 105,115,101,32,117,115,101,102,117,108,32,116,111,32,116,104, - 101,10,32,32,32,32,105,109,112,111,114,116,32,115,121,115, - 116,101,109,46,10,10,32,32,32,32,84,104,101,32,108,111, - 97,100,101,114,32,109,117,115,116,32,116,97,107,101,32,97, - 32,115,112,101,99,32,97,115,32,105,116,115,32,111,110,108, - 121,32,95,95,105,110,105,116,95,95,40,41,32,97,114,103, - 46,10,10,32,32,32,32,78,122,9,60,117,110,107,110,111, - 119,110,62,114,239,0,0,0,114,218,0,0,0,84,114,220, - 0,0,0,114,84,0,0,0,41,14,114,60,0,0,0,114, - 239,0,0,0,114,154,0,0,0,114,217,0,0,0,114,222, - 0,0,0,218,27,95,103,101,116,95,115,117,112,112,111,114, - 116,101,100,95,102,105,108,101,95,108,111,97,100,101,114,115, - 114,231,0,0,0,114,232,0,0,0,114,170,0,0,0,218, - 9,95,80,79,80,85,76,65,84,69,114,220,0,0,0,114, - 221,0,0,0,114,38,0,0,0,114,224,0,0,0,41,9, - 114,67,0,0,0,218,8,108,111,99,97,116,105,111,110,114, - 170,0,0,0,114,221,0,0,0,114,178,0,0,0,218,12, - 108,111,97,100,101,114,95,99,108,97,115,115,114,126,0,0, - 0,114,220,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,240, - 0,0,0,116,3,0,0,115,60,0,0,0,0,12,12,4, - 6,1,15,2,3,1,19,1,13,1,11,8,21,1,9,3, - 12,1,22,1,21,1,15,1,9,1,8,2,7,3,12,2, - 15,1,3,1,19,1,13,1,5,2,6,1,18,2,9,1, - 15,1,6,1,16,1,22,2,114,240,0,0,0,99,3,0, + 131,1,0,1,100,5,0,106,0,0,124,0,0,106,6,0, + 106,7,0,100,6,0,106,8,0,124,1,0,131,1,0,131, + 2,0,83,41,7,78,122,9,110,97,109,101,61,123,33,114, + 125,122,11,108,111,97,100,101,114,61,123,33,114,125,122,11, + 111,114,105,103,105,110,61,123,33,114,125,122,29,115,117,98, + 109,111,100,117,108,101,95,115,101,97,114,99,104,95,108,111, + 99,97,116,105,111,110,115,61,123,125,122,6,123,125,40,123, + 125,41,122,2,44,32,41,9,114,50,0,0,0,114,15,0, + 0,0,114,99,0,0,0,114,107,0,0,0,218,6,97,112, + 112,101,110,100,114,110,0,0,0,218,9,95,95,99,108,97, + 115,115,95,95,114,1,0,0,0,218,4,106,111,105,110,41, + 2,114,19,0,0,0,114,29,0,0,0,114,10,0,0,0, + 114,10,0,0,0,114,11,0,0,0,114,52,0,0,0,128, + 1,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,0,0,3,0,0,0,11,0,0,0,67,0, + 0,0,115,145,0,0,0,124,0,0,106,0,0,125,2,0, + 121,107,0,124,0,0,106,1,0,124,1,0,106,1,0,107, + 2,0,111,114,0,124,0,0,106,2,0,124,1,0,106,2, + 0,107,2,0,111,114,0,124,0,0,106,3,0,124,1,0, + 106,3,0,107,2,0,111,114,0,124,2,0,124,1,0,106, + 0,0,107,2,0,111,114,0,124,0,0,106,4,0,124,1, + 0,106,4,0,107,2,0,111,114,0,124,0,0,106,5,0, + 124,1,0,106,5,0,107,2,0,83,87,110,22,0,4,116, + 6,0,107,10,0,114,140,0,1,1,1,100,1,0,83,89, + 110,1,0,88,100,0,0,83,41,2,78,70,41,7,114,110, + 0,0,0,114,15,0,0,0,114,99,0,0,0,114,107,0, + 0,0,218,6,99,97,99,104,101,100,218,12,104,97,115,95, + 108,111,99,97,116,105,111,110,114,96,0,0,0,41,3,114, + 19,0,0,0,90,5,111,116,104,101,114,90,4,115,109,115, + 108,114,10,0,0,0,114,10,0,0,0,114,11,0,0,0, + 218,6,95,95,101,113,95,95,138,1,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,1,0,0,0,2,0,0,0,67,0,0,0,115,85,0, + 0,0,124,0,0,106,0,0,100,0,0,107,8,0,114,78, + 0,124,0,0,106,1,0,100,0,0,107,9,0,114,78,0, + 124,0,0,106,2,0,114,78,0,116,3,0,100,0,0,107, + 8,0,114,57,0,116,4,0,130,1,0,116,3,0,106,5, + 0,124,0,0,106,1,0,131,1,0,124,0,0,95,0,0, + 124,0,0,106,0,0,83,41,1,78,41,6,114,112,0,0, + 0,114,107,0,0,0,114,111,0,0,0,218,19,95,98,111, + 111,116,115,116,114,97,112,95,101,120,116,101,114,110,97,108, + 218,19,78,111,116,73,109,112,108,101,109,101,110,116,101,100, + 69,114,114,111,114,90,11,95,103,101,116,95,99,97,99,104, + 101,100,41,1,114,19,0,0,0,114,10,0,0,0,114,10, + 0,0,0,114,11,0,0,0,114,116,0,0,0,150,1,0, + 0,115,12,0,0,0,0,2,15,1,24,1,12,1,6,1, + 21,1,122,17,77,111,100,117,108,101,83,112,101,99,46,99, + 97,99,104,101,100,99,2,0,0,0,0,0,0,0,2,0, + 0,0,2,0,0,0,67,0,0,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,112,0,0,0,41,2,114,19,0,0,0,114,116,0, + 0,0,114,10,0,0,0,114,10,0,0,0,114,11,0,0, + 0,114,116,0,0,0,159,1,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,0,124,0,0,106,1,0, + 106,2,0,100,2,0,131,1,0,100,3,0,25,83,124,0, + 0,106,1,0,83,100,1,0,83,41,4,122,32,84,104,101, + 32,110,97,109,101,32,111,102,32,116,104,101,32,109,111,100, + 117,108,101,39,115,32,112,97,114,101,110,116,46,78,218,1, + 46,114,33,0,0,0,41,3,114,110,0,0,0,114,15,0, + 0,0,218,10,114,112,97,114,116,105,116,105,111,110,41,1, + 114,19,0,0,0,114,10,0,0,0,114,10,0,0,0,114, + 11,0,0,0,218,6,112,97,114,101,110,116,163,1,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,111,0,0,0,41,1,114,19,0,0,0, + 114,10,0,0,0,114,10,0,0,0,114,11,0,0,0,114, + 117,0,0,0,171,1,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,19,0, + 0,0,116,0,0,124,1,0,131,1,0,124,0,0,95,1, + 0,100,0,0,83,41,1,78,41,2,218,4,98,111,111,108, + 114,111,0,0,0,41,2,114,19,0,0,0,218,5,118,97, + 108,117,101,114,10,0,0,0,114,10,0,0,0,114,11,0, + 0,0,114,117,0,0,0,175,1,0,0,115,2,0,0,0, + 0,2,41,12,114,1,0,0,0,114,0,0,0,0,114,2, + 0,0,0,114,3,0,0,0,114,20,0,0,0,114,52,0, + 0,0,114,118,0,0,0,218,8,112,114,111,112,101,114,116, + 121,114,116,0,0,0,218,6,115,101,116,116,101,114,114,123, + 0,0,0,114,117,0,0,0,114,10,0,0,0,114,10,0, + 0,0,114,10,0,0,0,114,11,0,0,0,114,106,0,0, + 0,79,1,0,0,115,20,0,0,0,12,35,6,2,15,1, + 15,11,12,10,12,12,18,9,21,4,18,8,18,4,114,106, + 0,0,0,114,107,0,0,0,114,109,0,0,0,99,2,0, + 0,0,2,0,0,0,6,0,0,0,15,0,0,0,67,0, + 0,0,115,217,0,0,0,116,0,0,124,1,0,100,1,0, + 131,2,0,114,110,0,116,1,0,100,2,0,107,8,0,114, + 33,0,116,2,0,130,1,0,116,1,0,106,3,0,125,4, + 0,124,3,0,100,2,0,107,8,0,114,70,0,124,4,0, + 124,0,0,100,3,0,124,1,0,131,1,1,83,124,3,0, + 114,82,0,103,0,0,110,3,0,100,2,0,125,5,0,124, + 4,0,124,0,0,100,3,0,124,1,0,100,4,0,124,5, + 0,131,1,2,83,124,3,0,100,2,0,107,8,0,114,192, + 0,116,0,0,124,1,0,100,5,0,131,2,0,114,186,0, + 121,19,0,124,1,0,106,4,0,124,0,0,131,1,0,125, + 3,0,87,113,192,0,4,116,5,0,107,10,0,114,182,0, + 1,1,1,100,2,0,125,3,0,89,113,192,0,88,110,6, + 0,100,6,0,125,3,0,116,6,0,124,0,0,124,1,0, + 100,7,0,124,2,0,100,5,0,124,3,0,131,2,2,83, + 41,8,122,53,82,101,116,117,114,110,32,97,32,109,111,100, + 117,108,101,32,115,112,101,99,32,98,97,115,101,100,32,111, + 110,32,118,97,114,105,111,117,115,32,108,111,97,100,101,114, + 32,109,101,116,104,111,100,115,46,90,12,103,101,116,95,102, + 105,108,101,110,97,109,101,78,114,99,0,0,0,114,110,0, + 0,0,114,109,0,0,0,70,114,107,0,0,0,41,7,114, + 4,0,0,0,114,119,0,0,0,114,120,0,0,0,218,23, + 115,112,101,99,95,102,114,111,109,95,102,105,108,101,95,108, + 111,99,97,116,105,111,110,114,109,0,0,0,114,77,0,0, + 0,114,106,0,0,0,41,6,114,15,0,0,0,114,99,0, + 0,0,114,107,0,0,0,114,109,0,0,0,114,128,0,0, + 0,90,6,115,101,97,114,99,104,114,10,0,0,0,114,10, + 0,0,0,114,11,0,0,0,114,85,0,0,0,180,1,0, + 0,115,34,0,0,0,0,2,15,1,12,1,6,1,9,2, + 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,85,0,0,0,99,3,0, 0,0,0,0,0,0,8,0,0,0,53,0,0,0,67,0, - 0,0,115,124,1,0,0,121,13,0,124,0,0,106,0,0, + 0,0,115,118,1,0,0,121,13,0,124,0,0,106,0,0, 125,3,0,87,110,18,0,4,116,1,0,107,10,0,114,33, 0,1,1,1,89,110,17,0,88,124,3,0,100,0,0,107, 9,0,114,50,0,124,3,0,83,124,0,0,106,2,0,125, - 4,0,124,1,0,100,0,0,107,8,0,114,108,0,121,13, - 0,124,0,0,106,3,0,125,1,0,87,113,108,0,4,116, - 1,0,107,10,0,114,104,0,1,1,1,89,113,108,0,88, - 110,0,0,121,13,0,124,0,0,106,4,0,125,5,0,87, - 110,24,0,4,116,1,0,107,10,0,114,147,0,1,1,1, - 100,0,0,125,5,0,89,110,1,0,88,124,2,0,100,0, - 0,107,8,0,114,224,0,124,5,0,100,0,0,107,8,0, - 114,215,0,121,13,0,124,1,0,106,5,0,125,2,0,87, - 113,221,0,4,116,1,0,107,10,0,114,211,0,1,1,1, - 100,0,0,125,2,0,89,113,221,0,88,113,224,0,124,5, - 0,125,2,0,110,0,0,121,13,0,124,0,0,106,6,0, - 125,6,0,87,110,24,0,4,116,1,0,107,10,0,114,7, - 1,1,1,1,100,0,0,125,6,0,89,110,1,0,88,121, - 19,0,116,7,0,124,0,0,106,8,0,131,1,0,125,7, - 0,87,110,24,0,4,116,1,0,107,10,0,114,53,1,1, - 1,1,100,0,0,125,7,0,89,110,1,0,88,116,9,0, - 124,4,0,124,1,0,100,1,0,124,2,0,131,2,1,125, - 3,0,124,5,0,100,0,0,107,8,0,114,93,1,100,2, - 0,110,3,0,100,3,0,124,3,0,95,10,0,124,6,0, - 124,3,0,95,11,0,124,7,0,124,3,0,95,12,0,124, - 3,0,83,41,4,78,114,218,0,0,0,70,84,41,13,114, - 209,0,0,0,114,210,0,0,0,114,57,0,0,0,114,205, - 0,0,0,114,211,0,0,0,90,7,95,79,82,73,71,73, - 78,218,10,95,95,99,97,99,104,101,100,95,95,218,4,108, - 105,115,116,218,8,95,95,112,97,116,104,95,95,114,217,0, - 0,0,114,222,0,0,0,114,226,0,0,0,114,221,0,0, - 0,41,8,114,180,0,0,0,114,170,0,0,0,114,218,0, - 0,0,114,178,0,0,0,114,67,0,0,0,114,243,0,0, - 0,114,226,0,0,0,114,221,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,180,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,8,1, - 3,1,13,1,13,1,11,1,12,1,12,1,3,1,13,1, - 13,1,14,2,9,1,3,1,13,1,13,1,11,1,3,1, - 19,1,13,1,11,2,21,1,27,1,9,1,9,1,114,248, - 0,0,0,99,0,0,0,0,0,0,0,0,0,0,0,0, - 6,0,0,0,64,0,0,0,115,142,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,100,10,0,100,11,0,132,0,2,90,6,0,100, - 12,0,100,13,0,132,0,0,90,7,0,100,14,0,100,15, - 0,132,0,0,90,8,0,100,16,0,100,17,0,132,0,0, - 90,9,0,100,18,0,100,19,0,132,0,0,90,10,0,100, - 20,0,100,21,0,132,0,0,90,11,0,100,22,0,100,23, - 0,132,0,0,90,12,0,100,24,0,83,41,25,114,175,0, - 0,0,122,77,67,111,110,118,101,110,105,101,110,99,101,32, - 119,114,97,112,112,101,114,32,97,114,111,117,110,100,32,115, - 112,101,99,32,111,98,106,101,99,116,115,32,116,111,32,112, - 114,111,118,105,100,101,32,115,112,101,99,45,115,112,101,99, - 105,102,105,99,10,32,32,32,32,109,101,116,104,111,100,115, - 46,99,2,0,0,0,0,0,0,0,2,0,0,0,2,0, - 0,0,67,0,0,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,178,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,72,0, - 0,0,232,3,0,0,115,2,0,0,0,0,1,122,21,95, - 83,112,101,99,77,101,116,104,111,100,115,46,95,95,105,110, - 105,116,95,95,99,1,0,0,0,0,0,0,0,3,0,0, - 0,3,0,0,0,67,0,0,0,115,158,0,0,0,124,0, - 0,106,0,0,125,1,0,124,1,0,106,1,0,100,1,0, - 107,8,0,114,30,0,100,2,0,110,6,0,124,1,0,106, - 1,0,125,2,0,124,1,0,106,2,0,100,1,0,107,8, - 0,114,104,0,124,1,0,106,3,0,100,1,0,107,8,0, - 114,82,0,100,3,0,106,4,0,124,2,0,131,1,0,83, - 100,4,0,106,4,0,124,2,0,124,1,0,106,3,0,131, - 2,0,83,110,50,0,124,1,0,106,5,0,114,132,0,100, - 5,0,106,4,0,124,2,0,124,1,0,106,2,0,131,2, - 0,83,100,6,0,106,4,0,124,1,0,106,1,0,124,1, - 0,106,2,0,131,2,0,83,100,1,0,83,41,7,122,38, - 82,101,116,117,114,110,32,116,104,101,32,114,101,112,114,32, - 116,111,32,117,115,101,32,102,111,114,32,116,104,101,32,109, - 111,100,117,108,101,46,78,114,207,0,0,0,122,13,60,109, - 111,100,117,108,101,32,123,33,114,125,62,122,20,60,109,111, - 100,117,108,101,32,123,33,114,125,32,40,123,33,114,125,41, - 62,122,23,60,109,111,100,117,108,101,32,123,33,114,125,32, - 102,114,111,109,32,123,33,114,125,62,122,18,60,109,111,100, - 117,108,101,32,123,33,114,125,32,40,123,125,41,62,41,6, - 114,178,0,0,0,114,67,0,0,0,114,218,0,0,0,114, - 170,0,0,0,114,47,0,0,0,114,227,0,0,0,41,3, - 114,71,0,0,0,114,178,0,0,0,114,67,0,0,0,114, - 4,0,0,0,114,4,0,0,0,114,5,0,0,0,114,206, - 0,0,0,235,3,0,0,115,18,0,0,0,0,3,9,1, - 30,1,15,1,15,1,13,2,22,2,9,1,19,2,122,24, - 95,83,112,101,99,77,101,116,104,111,100,115,46,109,111,100, - 117,108,101,95,114,101,112,114,218,9,95,111,118,101,114,114, - 105,100,101,70,218,11,95,102,111,114,99,101,95,110,97,109, - 101,84,99,2,0,0,0,2,0,0,0,6,0,0,0,59, - 0,0,0,67,0,0,0,115,75,2,0,0,124,0,0,106, - 0,0,125,4,0,124,2,0,115,45,0,124,3,0,115,45, - 0,116,1,0,124,1,0,100,1,0,100,2,0,131,3,0, - 100,2,0,107,8,0,114,85,0,121,16,0,124,4,0,106, - 2,0,124,1,0,95,3,0,87,113,85,0,4,116,4,0, - 107,10,0,114,81,0,1,1,1,89,113,85,0,88,110,0, - 0,124,2,0,115,115,0,116,1,0,124,1,0,100,3,0, - 100,2,0,131,3,0,100,2,0,107,8,0,114,221,0,124, - 4,0,106,5,0,125,5,0,124,5,0,100,2,0,107,8, - 0,114,184,0,124,4,0,106,6,0,100,2,0,107,9,0, - 114,184,0,116,7,0,106,8,0,116,7,0,131,1,0,125, - 5,0,124,4,0,106,6,0,124,5,0,95,9,0,113,184, - 0,110,0,0,121,13,0,124,5,0,124,1,0,95,10,0, - 87,113,221,0,4,116,4,0,107,10,0,114,217,0,1,1, - 1,89,113,221,0,88,110,0,0,124,2,0,115,251,0,116, - 1,0,124,1,0,100,4,0,100,2,0,131,3,0,100,2, - 0,107,8,0,114,35,1,121,16,0,124,4,0,106,11,0, - 124,1,0,95,12,0,87,113,35,1,4,116,4,0,107,10, - 0,114,31,1,1,1,1,89,113,35,1,88,110,0,0,121, - 13,0,124,4,0,124,1,0,95,13,0,87,110,18,0,4, - 116,4,0,107,10,0,114,68,1,1,1,1,89,110,1,0, - 88,124,2,0,115,99,1,116,1,0,124,1,0,100,5,0, - 100,2,0,131,3,0,100,2,0,107,8,0,114,157,1,124, - 4,0,106,6,0,100,2,0,107,9,0,114,157,1,121,16, - 0,124,4,0,106,6,0,124,1,0,95,14,0,87,113,154, - 1,4,116,4,0,107,10,0,114,150,1,1,1,1,89,113, - 154,1,88,113,157,1,110,0,0,124,4,0,106,15,0,114, - 71,2,124,2,0,115,196,1,116,1,0,124,1,0,100,6, - 0,100,2,0,131,3,0,100,2,0,107,8,0,114,236,1, - 121,16,0,124,4,0,106,16,0,124,1,0,95,17,0,87, - 113,236,1,4,116,4,0,107,10,0,114,232,1,1,1,1, - 89,113,236,1,88,110,0,0,124,2,0,115,10,2,116,1, - 0,124,1,0,100,7,0,100,2,0,131,3,0,100,2,0, - 107,8,0,114,71,2,124,4,0,106,18,0,100,2,0,107, - 9,0,114,68,2,121,16,0,124,4,0,106,18,0,124,1, - 0,95,19,0,87,113,65,2,4,116,4,0,107,10,0,114, - 61,2,1,1,1,89,113,65,2,88,113,68,2,113,71,2, - 110,0,0,100,2,0,83,41,8,97,29,2,0,0,83,101, - 116,32,116,104,101,32,109,111,100,117,108,101,39,115,32,97, - 116,116,114,105,98,117,116,101,115,46,10,10,32,32,32,32, - 32,32,32,32,65,108,108,32,109,105,115,115,105,110,103,32, - 105,109,112,111,114,116,45,114,101,108,97,116,101,100,32,109, - 111,100,117,108,101,32,97,116,116,114,105,98,117,116,101,115, - 32,119,105,108,108,32,98,101,32,115,101,116,46,32,32,72, - 101,114,101,10,32,32,32,32,32,32,32,32,105,115,32,104, - 111,119,32,116,104,101,32,115,112,101,99,32,97,116,116,114, - 105,98,117,116,101,115,32,109,97,112,32,111,110,116,111,32, - 116,104,101,32,109,111,100,117,108,101,58,10,10,32,32,32, - 32,32,32,32,32,115,112,101,99,46,110,97,109,101,32,45, - 62,32,109,111,100,117,108,101,46,95,95,110,97,109,101,95, - 95,10,32,32,32,32,32,32,32,32,115,112,101,99,46,108, - 111,97,100,101,114,32,45,62,32,109,111,100,117,108,101,46, - 95,95,108,111,97,100,101,114,95,95,10,32,32,32,32,32, - 32,32,32,115,112,101,99,46,112,97,114,101,110,116,32,45, - 62,32,109,111,100,117,108,101,46,95,95,112,97,99,107,97, - 103,101,95,95,10,32,32,32,32,32,32,32,32,115,112,101, - 99,32,45,62,32,109,111,100,117,108,101,46,95,95,115,112, - 101,99,95,95,10,10,32,32,32,32,32,32,32,32,79,112, - 116,105,111,110,97,108,58,10,32,32,32,32,32,32,32,32, - 115,112,101,99,46,111,114,105,103,105,110,32,45,62,32,109, - 111,100,117,108,101,46,95,95,102,105,108,101,95,95,32,40, - 105,102,32,115,112,101,99,46,115,101,116,95,102,105,108,101, - 97,116,116,114,32,105,115,32,116,114,117,101,41,10,32,32, - 32,32,32,32,32,32,115,112,101,99,46,99,97,99,104,101, - 100,32,45,62,32,109,111,100,117,108,101,46,95,95,99,97, - 99,104,101,100,95,95,32,40,105,102,32,95,95,102,105,108, - 101,95,95,32,97,108,115,111,32,115,101,116,41,10,32,32, - 32,32,32,32,32,32,115,112,101,99,46,115,117,98,109,111, - 100,117,108,101,95,115,101,97,114,99,104,95,108,111,99,97, - 116,105,111,110,115,32,45,62,32,109,111,100,117,108,101,46, - 95,95,112,97,116,104,95,95,32,40,105,102,32,115,101,116, - 41,10,10,32,32,32,32,32,32,32,32,114,57,0,0,0, - 78,114,205,0,0,0,218,11,95,95,112,97,99,107,97,103, - 101,95,95,114,247,0,0,0,114,211,0,0,0,114,245,0, - 0,0,41,20,114,178,0,0,0,114,62,0,0,0,114,67, - 0,0,0,114,57,0,0,0,114,210,0,0,0,114,170,0, - 0,0,114,221,0,0,0,218,16,95,78,97,109,101,115,112, - 97,99,101,76,111,97,100,101,114,218,7,95,95,110,101,119, - 95,95,218,5,95,112,97,116,104,114,205,0,0,0,114,234, - 0,0,0,114,251,0,0,0,114,209,0,0,0,114,247,0, - 0,0,114,227,0,0,0,114,218,0,0,0,114,211,0,0, - 0,114,226,0,0,0,114,245,0,0,0,41,6,114,71,0, - 0,0,114,180,0,0,0,114,249,0,0,0,114,250,0,0, - 0,114,178,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,105,110,105,116, - 95,109,111,100,117,108,101,95,97,116,116,114,115,251,3,0, - 0,115,88,0,0,0,0,17,9,6,12,1,24,1,3,1, - 16,1,13,1,8,3,30,1,9,1,12,2,15,1,15,1, - 18,1,3,1,13,1,13,1,8,3,30,1,3,1,16,1, - 13,1,8,3,3,1,13,1,13,1,5,3,30,1,15,1, - 3,1,16,1,13,1,11,2,9,2,30,1,3,1,16,1, - 13,1,8,3,30,1,15,1,3,1,16,1,13,1,122,30, - 95,83,112,101,99,77,101,116,104,111,100,115,46,105,110,105, - 116,95,109,111,100,117,108,101,95,97,116,116,114,115,99,1, - 0,0,0,0,0,0,0,3,0,0,0,3,0,0,0,67, - 0,0,0,115,101,0,0,0,124,0,0,106,0,0,125,1, - 0,116,1,0,124,1,0,106,2,0,100,1,0,131,2,0, - 114,48,0,124,1,0,106,2,0,106,3,0,124,1,0,131, - 1,0,125,2,0,110,6,0,100,2,0,125,2,0,124,2, - 0,100,2,0,107,8,0,114,84,0,116,4,0,124,1,0, - 106,5,0,131,1,0,125,2,0,110,0,0,124,0,0,106, - 6,0,124,2,0,131,1,0,1,124,2,0,83,41,3,122, - 153,82,101,116,117,114,110,32,97,32,110,101,119,32,109,111, - 100,117,108,101,32,116,111,32,98,101,32,108,111,97,100,101, - 100,46,10,10,32,32,32,32,32,32,32,32,84,104,101,32, - 105,109,112,111,114,116,45,114,101,108,97,116,101,100,32,109, - 111,100,117,108,101,32,97,116,116,114,105,98,117,116,101,115, - 32,97,114,101,32,97,108,115,111,32,115,101,116,32,119,105, - 116,104,32,116,104,101,10,32,32,32,32,32,32,32,32,97, - 112,112,114,111,112,114,105,97,116,101,32,118,97,108,117,101, - 115,32,102,114,111,109,32,116,104,101,32,115,112,101,99,46, - 10,10,32,32,32,32,32,32,32,32,218,13,99,114,101,97, - 116,101,95,109,111,100,117,108,101,78,41,7,114,178,0,0, - 0,114,60,0,0,0,114,170,0,0,0,114,0,1,0,0, - 114,68,0,0,0,114,67,0,0,0,114,255,0,0,0,41, - 3,114,71,0,0,0,114,178,0,0,0,114,180,0,0,0, - 114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,218, - 6,99,114,101,97,116,101,75,4,0,0,115,16,0,0,0, - 0,7,9,2,18,3,21,2,6,1,12,4,18,1,13,1, - 122,19,95,83,112,101,99,77,101,116,104,111,100,115,46,99, - 114,101,97,116,101,99,2,0,0,0,0,0,0,0,2,0, - 0,0,2,0,0,0,67,0,0,0,115,23,0,0,0,124, - 0,0,106,0,0,106,1,0,106,2,0,124,1,0,131,1, - 0,1,100,1,0,83,41,2,122,189,68,111,32,101,118,101, - 114,121,116,104,105,110,103,32,110,101,99,101,115,115,97,114, - 121,32,116,111,32,101,120,101,99,117,116,101,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,110,97,109,101,115,112,97,99,101,32, - 111,102,32,96,109,111,100,117,108,101,96,32,105,115,32,117, - 115,101,100,32,97,115,32,116,104,101,32,116,97,114,103,101, - 116,32,111,102,32,101,120,101,99,117,116,105,111,110,46,10, - 32,32,32,32,32,32,32,32,84,104,105,115,32,109,101,116, - 104,111,100,32,117,115,101,115,32,116,104,101,32,108,111,97, - 100,101,114,39,115,32,96,101,120,101,99,95,109,111,100,117, - 108,101,40,41,96,32,109,101,116,104,111,100,46,10,10,32, - 32,32,32,32,32,32,32,78,41,3,114,178,0,0,0,114, - 170,0,0,0,218,11,101,120,101,99,95,109,111,100,117,108, - 101,41,2,114,71,0,0,0,114,180,0,0,0,114,4,0, - 0,0,114,4,0,0,0,114,5,0,0,0,218,5,95,101, - 120,101,99,98,4,0,0,115,2,0,0,0,0,7,122,18, - 95,83,112,101,99,77,101,116,104,111,100,115,46,95,101,120, - 101,99,99,2,0,0,0,0,0,0,0,4,0,0,0,11, - 0,0,0,67,0,0,0,115,17,1,0,0,124,0,0,106, - 0,0,106,1,0,125,2,0,116,2,0,106,3,0,131,0, - 0,1,116,4,0,124,2,0,131,1,0,143,226,0,1,116, - 5,0,106,6,0,106,7,0,124,2,0,131,1,0,124,1, - 0,107,9,0,114,95,0,100,1,0,106,8,0,124,2,0, - 131,1,0,125,3,0,116,9,0,124,3,0,100,2,0,124, - 2,0,131,1,1,130,1,0,110,0,0,124,0,0,106,0, - 0,106,10,0,100,3,0,107,8,0,114,181,0,124,0,0, - 106,0,0,106,11,0,100,3,0,107,8,0,114,158,0,116, - 9,0,100,4,0,100,2,0,124,0,0,106,0,0,106,1, - 0,131,1,1,130,1,0,110,0,0,124,0,0,106,12,0, - 124,1,0,100,5,0,100,6,0,131,1,1,1,124,1,0, - 83,124,0,0,106,12,0,124,1,0,100,5,0,100,6,0, - 131,1,1,1,116,13,0,124,0,0,106,0,0,106,10,0, - 100,7,0,131,2,0,115,243,0,124,0,0,106,0,0,106, - 10,0,106,14,0,124,2,0,131,1,0,1,110,13,0,124, - 0,0,106,15,0,124,1,0,131,1,0,1,87,100,3,0, - 81,88,116,5,0,106,6,0,124,2,0,25,83,41,8,122, - 51,69,120,101,99,117,116,101,32,116,104,101,32,115,112,101, - 99,32,105,110,32,97,110,32,101,120,105,115,116,105,110,103, - 32,109,111,100,117,108,101,39,115,32,110,97,109,101,115,112, - 97,99,101,46,122,30,109,111,100,117,108,101,32,123,33,114, - 125,32,110,111,116,32,105,110,32,115,121,115,46,109,111,100, - 117,108,101,115,114,67,0,0,0,78,122,14,109,105,115,115, - 105,110,103,32,108,111,97,100,101,114,114,249,0,0,0,84, - 114,2,1,0,0,41,16,114,178,0,0,0,114,67,0,0, - 0,114,106,0,0,0,218,12,97,99,113,117,105,114,101,95, - 108,111,99,107,114,103,0,0,0,114,7,0,0,0,114,73, - 0,0,0,114,93,0,0,0,114,47,0,0,0,114,154,0, - 0,0,114,170,0,0,0,114,221,0,0,0,114,255,0,0, - 0,114,60,0,0,0,218,11,108,111,97,100,95,109,111,100, - 117,108,101,114,3,1,0,0,41,4,114,71,0,0,0,114, - 180,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,176,0, - 0,0,108,4,0,0,115,32,0,0,0,0,2,12,1,10, - 1,13,1,24,1,15,1,21,1,18,1,18,1,27,2,19, - 1,4,1,19,1,21,4,22,2,19,1,122,17,95,83,112, - 101,99,77,101,116,104,111,100,115,46,101,120,101,99,99,1, - 0,0,0,0,0,0,0,3,0,0,0,27,0,0,0,67, - 0,0,0,115,24,1,0,0,124,0,0,106,0,0,125,1, - 0,124,1,0,106,1,0,106,2,0,124,1,0,106,3,0, - 131,1,0,1,116,4,0,106,5,0,124,1,0,106,3,0, - 25,125,2,0,116,6,0,124,2,0,100,1,0,100,0,0, - 131,3,0,100,0,0,107,8,0,114,108,0,121,16,0,124, - 1,0,106,1,0,124,2,0,95,7,0,87,113,108,0,4, - 116,8,0,107,10,0,114,104,0,1,1,1,89,113,108,0, - 88,110,0,0,116,6,0,124,2,0,100,2,0,100,0,0, - 131,3,0,100,0,0,107,8,0,114,215,0,121,59,0,124, - 2,0,106,9,0,124,2,0,95,10,0,116,11,0,124,2, - 0,100,3,0,131,2,0,115,190,0,124,1,0,106,3,0, - 106,12,0,100,4,0,131,1,0,100,5,0,25,124,2,0, - 95,10,0,110,0,0,87,113,215,0,4,116,8,0,107,10, - 0,114,211,0,1,1,1,89,113,215,0,88,110,0,0,116, - 6,0,124,2,0,100,6,0,100,0,0,131,3,0,100,0, - 0,107,8,0,114,20,1,121,13,0,124,1,0,124,2,0, - 95,13,0,87,113,20,1,4,116,8,0,107,10,0,114,16, - 1,1,1,1,89,113,20,1,88,110,0,0,124,2,0,83, - 41,7,78,114,205,0,0,0,114,251,0,0,0,114,247,0, - 0,0,114,116,0,0,0,114,84,0,0,0,114,209,0,0, - 0,41,14,114,178,0,0,0,114,170,0,0,0,114,5,1, - 0,0,114,67,0,0,0,114,7,0,0,0,114,73,0,0, - 0,114,62,0,0,0,114,205,0,0,0,114,210,0,0,0, - 114,57,0,0,0,114,251,0,0,0,114,60,0,0,0,114, - 32,0,0,0,114,209,0,0,0,41,3,114,71,0,0,0, - 114,178,0,0,0,114,180,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,132,4,0,0,115,42,0,0,0,0,4,9, - 1,19,2,16,1,24,1,3,1,16,1,13,1,8,1,24, - 1,3,4,12,1,15,1,32,1,13,1,8,1,24,1,3, - 1,13,1,13,1,8,1,122,38,95,83,112,101,99,77,101, - 116,104,111,100,115,46,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,99, - 1,0,0,0,0,0,0,0,2,0,0,0,11,0,0,0, - 67,0,0,0,115,179,0,0,0,124,0,0,106,0,0,106, - 1,0,100,0,0,107,9,0,114,52,0,116,2,0,124,0, - 0,106,0,0,106,1,0,100,1,0,131,2,0,115,52,0, - 124,0,0,106,3,0,131,0,0,83,110,0,0,124,0,0, - 106,4,0,131,0,0,125,1,0,116,5,0,124,1,0,131, - 1,0,143,84,0,1,124,0,0,106,0,0,106,1,0,100, - 0,0,107,8,0,114,143,0,124,0,0,106,0,0,106,6, - 0,100,0,0,107,8,0,114,156,0,116,7,0,100,2,0, - 100,3,0,124,0,0,106,0,0,106,8,0,131,1,1,130, - 1,0,113,156,0,110,13,0,124,0,0,106,9,0,124,1, - 0,131,1,0,1,87,100,0,0,81,88,116,10,0,106,11, - 0,124,0,0,106,0,0,106,8,0,25,83,41,4,78,114, - 2,1,0,0,122,14,109,105,115,115,105,110,103,32,108,111, - 97,100,101,114,114,67,0,0,0,41,12,114,178,0,0,0, - 114,170,0,0,0,114,60,0,0,0,114,6,1,0,0,114, - 1,1,0,0,114,213,0,0,0,114,221,0,0,0,114,154, - 0,0,0,114,67,0,0,0,114,3,1,0,0,114,7,0, - 0,0,114,73,0,0,0,41,2,114,71,0,0,0,114,180, - 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,162,4,0,0,115,20,0,0,0,0,2,18,2,21, - 1,13,2,12,1,13,1,18,1,18,1,30,3,19,5,122, - 27,95,83,112,101,99,77,101,116,104,111,100,115,46,95,108, - 111,97,100,95,117,110,108,111,99,107,101,100,99,1,0,0, - 0,0,0,0,0,1,0,0,0,8,0,0,0,67,0,0, - 0,115,49,0,0,0,116,0,0,106,1,0,131,0,0,1, - 116,2,0,124,0,0,106,3,0,106,4,0,131,1,0,143, - 15,0,1,124,0,0,106,5,0,131,0,0,83,87,100,1, - 0,81,88,100,1,0,83,41,2,122,207,82,101,116,117,114, - 110,32,97,32,110,101,119,32,109,111,100,117,108,101,32,111, - 98,106,101,99,116,44,32,108,111,97,100,101,100,32,98,121, - 32,116,104,101,32,115,112,101,99,39,115,32,108,111,97,100, - 101,114,46,10,10,32,32,32,32,32,32,32,32,84,104,101, - 32,109,111,100,117,108,101,32,105,115,32,110,111,116,32,97, - 100,100,101,100,32,116,111,32,105,116,115,32,112,97,114,101, - 110,116,46,10,10,32,32,32,32,32,32,32,32,73,102,32, - 97,32,109,111,100,117,108,101,32,105,115,32,97,108,114,101, - 97,100,121,32,105,110,32,115,121,115,46,109,111,100,117,108, - 101,115,44,32,116,104,97,116,32,101,120,105,115,116,105,110, - 103,32,109,111,100,117,108,101,32,103,101,116,115,10,32,32, - 32,32,32,32,32,32,99,108,111,98,98,101,114,101,100,46, - 10,10,32,32,32,32,32,32,32,32,78,41,6,114,106,0, - 0,0,114,4,1,0,0,114,103,0,0,0,114,178,0,0, - 0,114,67,0,0,0,114,7,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,177,0,0,0,185,4,0,0,115,6,0,0,0,0, - 9,10,1,19,1,122,17,95,83,112,101,99,77,101,116,104, - 111,100,115,46,108,111,97,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,206,0,0,0,114,255,0,0,0,114,1, - 1,0,0,114,3,1,0,0,114,176,0,0,0,114,6,1, - 0,0,114,7,1,0,0,114,177,0,0,0,114,4,0,0, - 0,114,4,0,0,0,114,4,0,0,0,114,5,0,0,0, - 114,175,0,0,0,225,3,0,0,115,20,0,0,0,12,3, - 6,4,12,3,12,16,24,80,12,23,12,10,12,24,12,30, - 12,23,114,175,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,201,0,0, - 0,124,0,0,106,0,0,100,1,0,131,1,0,125,4,0, - 124,0,0,106,0,0,100,2,0,131,1,0,125,5,0,124, - 4,0,115,102,0,124,5,0,114,54,0,124,5,0,106,1, - 0,125,4,0,113,102,0,124,2,0,124,3,0,107,2,0, - 114,84,0,116,2,0,124,1,0,124,2,0,131,2,0,125, - 4,0,113,102,0,116,3,0,124,1,0,124,2,0,131,2, - 0,125,4,0,110,0,0,124,5,0,115,132,0,116,4,0, - 124,1,0,124,2,0,100,3,0,124,4,0,131,2,1,125, - 5,0,110,0,0,121,44,0,124,5,0,124,0,0,100,2, - 0,60,124,4,0,124,0,0,100,1,0,60,124,2,0,124, - 0,0,100,4,0,60,124,3,0,124,0,0,100,5,0,60, - 87,110,18,0,4,116,5,0,107,10,0,114,196,0,1,1, - 1,89,110,1,0,88,100,0,0,83,41,6,78,114,205,0, - 0,0,114,209,0,0,0,114,170,0,0,0,114,211,0,0, - 0,114,245,0,0,0,41,6,114,93,0,0,0,114,170,0, - 0,0,218,20,83,111,117,114,99,101,108,101,115,115,70,105, - 108,101,76,111,97,100,101,114,218,16,83,111,117,114,99,101, - 70,105,108,101,76,111,97,100,101,114,114,240,0,0,0,114, - 208,0,0,0,41,6,90,2,110,115,114,67,0,0,0,90, - 8,112,97,116,104,110,97,109,101,90,9,99,112,97,116,104, - 110,97,109,101,114,170,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, - 102,105,120,95,117,112,95,109,111,100,117,108,101,199,4,0, - 0,115,34,0,0,0,0,2,15,1,15,1,6,1,6,1, - 12,1,12,1,18,2,18,1,6,1,24,1,3,1,10,1, - 10,1,10,1,14,1,13,2,114,10,1,0,0,99,0,0, - 0,0,0,0,0,0,0,0,0,0,5,0,0,0,64,0, - 0,0,115,181,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,6,0,100,4, - 0,100,4,0,100,5,0,100,6,0,132,2,0,131,1,0, - 90,7,0,101,6,0,100,4,0,100,7,0,100,8,0,132, - 1,0,131,1,0,90,8,0,101,6,0,101,9,0,100,9, - 0,100,10,0,132,0,0,131,1,0,131,1,0,90,10,0, - 101,6,0,101,9,0,100,11,0,100,12,0,132,0,0,131, - 1,0,131,1,0,90,11,0,101,6,0,101,9,0,100,13, - 0,100,14,0,132,0,0,131,1,0,131,1,0,90,12,0, - 101,6,0,101,9,0,100,15,0,100,16,0,132,0,0,131, - 1,0,131,1,0,90,13,0,100,4,0,83,41,17,218,15, - 66,117,105,108,116,105,110,73,109,112,111,114,116,101,114,122, - 144,77,101,116,97,32,112,97,116,104,32,105,109,112,111,114, - 116,32,102,111,114,32,98,117,105,108,116,45,105,110,32,109, - 111,100,117,108,101,115,46,10,10,32,32,32,32,65,108,108, - 32,109,101,116,104,111,100,115,32,97,114,101,32,101,105,116, - 104,101,114,32,99,108,97,115,115,32,111,114,32,115,116,97, - 116,105,99,32,109,101,116,104,111,100,115,32,116,111,32,97, - 118,111,105,100,32,116,104,101,32,110,101,101,100,32,116,111, - 10,32,32,32,32,105,110,115,116,97,110,116,105,97,116,101, - 32,116,104,101,32,99,108,97,115,115,46,10,10,32,32,32, - 32,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,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,24,60,109,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,180,0,0,0,114, - 4,0,0,0,114,4,0,0,0,114,5,0,0,0,114,206, - 0,0,0,233,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,0,0,0,5,0,0,0,67,0,0, - 0,115,58,0,0,0,124,2,0,100,0,0,107,9,0,114, - 16,0,100,0,0,83,116,0,0,106,1,0,124,1,0,131, - 1,0,114,50,0,116,2,0,124,1,0,124,0,0,100,1, - 0,100,2,0,131,2,1,83,100,0,0,83,100,0,0,83, - 41,3,78,114,218,0,0,0,122,8,98,117,105,108,116,45, - 105,110,41,3,114,106,0,0,0,90,10,105,115,95,98,117, - 105,108,116,105,110,114,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,242,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,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,9,0, - 114,37,0,124,3,0,106,1,0,83,100,1,0,83,41,2, - 122,175,70,105,110,100,32,116,104,101,32,98,117,105,108,116, - 45,105,110,32,109,111,100,117,108,101,46,10,10,32,32,32, - 32,32,32,32,32,73,102,32,39,112,97,116,104,39,32,105, - 115,32,101,118,101,114,32,115,112,101,99,105,102,105,101,100, - 32,116,104,101,110,32,116,104,101,32,115,101,97,114,99,104, - 32,105,115,32,99,111,110,115,105,100,101,114,101,100,32,97, - 32,102,97,105,108,117,114,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,14,1,0,0,114,170,0,0,0,41,4, - 114,12,1,0,0,114,159,0,0,0,114,35,0,0,0,114, - 178,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, - 251,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,0,10,0,0,0,67,0,0,0,115, - 59,0,0,0,116,0,0,124,1,0,131,1,0,143,23,0, - 1,116,1,0,116,2,0,106,3,0,124,1,0,131,2,0, - 125,2,0,87,100,1,0,81,88,124,0,0,124,2,0,95, - 4,0,100,2,0,124,2,0,95,5,0,124,2,0,83,41, - 3,122,23,76,111,97,100,32,97,32,98,117,105,108,116,45, - 105,110,32,109,111,100,117,108,101,46,78,114,30,0,0,0, - 41,6,114,69,0,0,0,114,114,0,0,0,114,106,0,0, - 0,90,12,105,110,105,116,95,98,117,105,108,116,105,110,114, - 205,0,0,0,114,251,0,0,0,41,3,114,12,1,0,0, - 114,159,0,0,0,114,180,0,0,0,114,4,0,0,0,114, - 4,0,0,0,114,5,0,0,0,114,5,1,0,0,7,5, - 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, + 4,0,124,1,0,100,0,0,107,8,0,114,105,0,121,13, + 0,124,0,0,106,3,0,125,1,0,87,110,18,0,4,116, + 1,0,107,10,0,114,104,0,1,1,1,89,110,1,0,88, + 121,13,0,124,0,0,106,4,0,125,5,0,87,110,24,0, + 4,116,1,0,107,10,0,114,144,0,1,1,1,100,0,0, + 125,5,0,89,110,1,0,88,124,2,0,100,0,0,107,8, + 0,114,218,0,124,5,0,100,0,0,107,8,0,114,212,0, + 121,13,0,124,1,0,106,5,0,125,2,0,87,113,218,0, + 4,116,1,0,107,10,0,114,208,0,1,1,1,100,0,0, + 125,2,0,89,113,218,0,88,110,6,0,124,5,0,125,2, + 0,121,13,0,124,0,0,106,6,0,125,6,0,87,110,24, + 0,4,116,1,0,107,10,0,114,1,1,1,1,1,100,0, + 0,125,6,0,89,110,1,0,88,121,19,0,116,7,0,124, + 0,0,106,8,0,131,1,0,125,7,0,87,110,24,0,4, + 116,1,0,107,10,0,114,47,1,1,1,1,100,0,0,125, + 7,0,89,110,1,0,88,116,9,0,124,4,0,124,1,0, + 100,1,0,124,2,0,131,2,1,125,3,0,124,5,0,100, + 0,0,107,8,0,114,87,1,100,2,0,110,3,0,100,3, + 0,124,3,0,95,10,0,124,6,0,124,3,0,95,11,0, + 124,7,0,124,3,0,95,12,0,124,3,0,83,41,4,78, + 114,107,0,0,0,70,84,41,13,114,95,0,0,0,114,96, + 0,0,0,114,1,0,0,0,114,91,0,0,0,114,98,0, + 0,0,90,7,95,79,82,73,71,73,78,218,10,95,95,99, + 97,99,104,101,100,95,95,218,4,108,105,115,116,218,8,95, + 95,112,97,116,104,95,95,114,106,0,0,0,114,111,0,0, + 0,114,116,0,0,0,114,110,0,0,0,41,8,114,89,0, + 0,0,114,99,0,0,0,114,107,0,0,0,114,88,0,0, + 0,114,15,0,0,0,90,8,108,111,99,97,116,105,111,110, + 114,116,0,0,0,114,110,0,0,0,114,10,0,0,0,114, + 10,0,0,0,114,11,0,0,0,218,17,95,115,112,101,99, + 95,102,114,111,109,95,109,111,100,117,108,101,209,1,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,13, + 1,14,2,6,1,3,1,13,1,13,1,11,1,3,1,19, + 1,13,1,11,2,21,1,27,1,9,1,9,1,114,132,0, + 0,0,218,8,111,118,101,114,114,105,100,101,70,99,2,0, + 0,0,1,0,0,0,5,0,0,0,59,0,0,0,67,0, + 0,0,115,54,2,0,0,124,2,0,115,30,0,116,0,0, + 124,1,0,100,1,0,100,0,0,131,3,0,100,0,0,107, + 8,0,114,67,0,121,16,0,124,0,0,106,1,0,124,1, + 0,95,2,0,87,110,18,0,4,116,3,0,107,10,0,114, + 66,0,1,1,1,89,110,1,0,88,124,2,0,115,97,0, + 116,0,0,124,1,0,100,2,0,100,0,0,131,3,0,100, + 0,0,107,8,0,114,221,0,124,0,0,106,4,0,125,3, + 0,124,3,0,100,0,0,107,8,0,114,187,0,124,0,0, + 106,5,0,100,0,0,107,9,0,114,187,0,116,6,0,100, + 0,0,107,8,0,114,151,0,116,7,0,130,1,0,116,6, + 0,106,8,0,125,4,0,124,4,0,106,9,0,124,4,0, + 131,1,0,125,3,0,124,0,0,106,5,0,124,3,0,95, + 10,0,121,13,0,124,3,0,124,1,0,95,11,0,87,110, + 18,0,4,116,3,0,107,10,0,114,220,0,1,1,1,89, + 110,1,0,88,124,2,0,115,251,0,116,0,0,124,1,0, + 100,3,0,100,0,0,131,3,0,100,0,0,107,8,0,114, + 32,1,121,16,0,124,0,0,106,12,0,124,1,0,95,13, + 0,87,110,18,0,4,116,3,0,107,10,0,114,31,1,1, + 1,1,89,110,1,0,88,121,13,0,124,0,0,124,1,0, + 95,14,0,87,110,18,0,4,116,3,0,107,10,0,114,65, + 1,1,1,1,89,110,1,0,88,124,2,0,115,96,1,116, + 0,0,124,1,0,100,4,0,100,0,0,131,3,0,100,0, + 0,107,8,0,114,148,1,124,0,0,106,5,0,100,0,0, + 107,9,0,114,148,1,121,16,0,124,0,0,106,5,0,124, + 1,0,95,15,0,87,110,18,0,4,116,3,0,107,10,0, + 114,147,1,1,1,1,89,110,1,0,88,124,0,0,106,16, + 0,114,50,2,124,2,0,115,187,1,116,0,0,124,1,0, + 100,5,0,100,0,0,131,3,0,100,0,0,107,8,0,114, + 224,1,121,16,0,124,0,0,106,17,0,124,1,0,95,18, + 0,87,110,18,0,4,116,3,0,107,10,0,114,223,1,1, + 1,1,89,110,1,0,88,124,2,0,115,254,1,116,0,0, + 124,1,0,100,6,0,100,0,0,131,3,0,100,0,0,107, + 8,0,114,50,2,124,0,0,106,19,0,100,0,0,107,9, + 0,114,50,2,121,16,0,124,0,0,106,19,0,124,1,0, + 95,20,0,87,110,18,0,4,116,3,0,107,10,0,114,49, + 2,1,1,1,89,110,1,0,88,124,1,0,83,41,7,78, + 114,1,0,0,0,114,91,0,0,0,218,11,95,95,112,97, + 99,107,97,103,101,95,95,114,131,0,0,0,114,98,0,0, + 0,114,129,0,0,0,41,21,114,6,0,0,0,114,15,0, + 0,0,114,1,0,0,0,114,96,0,0,0,114,99,0,0, + 0,114,110,0,0,0,114,119,0,0,0,114,120,0,0,0, + 218,16,95,78,97,109,101,115,112,97,99,101,76,111,97,100, + 101,114,218,7,95,95,110,101,119,95,95,90,5,95,112,97, + 116,104,114,91,0,0,0,114,123,0,0,0,114,134,0,0, + 0,114,95,0,0,0,114,131,0,0,0,114,117,0,0,0, + 114,107,0,0,0,114,98,0,0,0,114,116,0,0,0,114, + 129,0,0,0,41,5,114,88,0,0,0,114,89,0,0,0, + 114,133,0,0,0,114,99,0,0,0,114,135,0,0,0,114, + 10,0,0,0,114,10,0,0,0,114,11,0,0,0,218,18, + 95,105,110,105,116,95,109,111,100,117,108,101,95,97,116,116, + 114,115,254,1,0,0,115,92,0,0,0,0,4,30,1,3, + 1,16,1,13,1,5,2,30,1,9,1,12,2,15,1,12, + 1,6,1,9,2,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,13, + 1,5,2,30,1,15,1,3,1,16,1,13,1,5,2,9, + 1,30,1,3,1,16,1,13,1,5,2,30,1,15,1,3, + 1,16,1,13,1,5,1,114,137,0,0,0,99,1,0,0, + 0,0,0,0,0,2,0,0,0,5,0,0,0,67,0,0, + 0,115,129,0,0,0,100,1,0,125,1,0,116,0,0,124, + 0,0,106,1,0,100,2,0,131,2,0,114,45,0,124,0, + 0,106,1,0,106,2,0,124,0,0,131,1,0,125,1,0, + 110,40,0,116,0,0,124,0,0,106,1,0,100,3,0,131, + 2,0,114,85,0,116,3,0,106,4,0,100,4,0,116,5, + 0,100,5,0,100,6,0,131,2,1,1,124,1,0,100,1, + 0,107,8,0,114,112,0,116,6,0,124,0,0,106,7,0, + 131,1,0,125,1,0,116,8,0,124,0,0,124,1,0,131, + 2,0,1,124,1,0,83,41,7,122,43,67,114,101,97,116, + 101,32,97,32,109,111,100,117,108,101,32,98,97,115,101,100, + 32,111,110,32,116,104,101,32,112,114,111,118,105,100,101,100, + 32,115,112,101,99,46,78,218,13,99,114,101,97,116,101,95, + 109,111,100,117,108,101,218,11,101,120,101,99,95,109,111,100, + 117,108,101,122,87,115,116,97,114,116,105,110,103,32,105,110, + 32,80,121,116,104,111,110,32,51,46,54,44,32,108,111,97, + 100,101,114,115,32,100,101,102,105,110,105,110,103,32,101,120, + 101,99,95,109,111,100,117,108,101,40,41,32,109,117,115,116, + 32,97,108,115,111,32,100,101,102,105,110,101,32,99,114,101, + 97,116,101,95,109,111,100,117,108,101,40,41,90,10,115,116, + 97,99,107,108,101,118,101,108,233,2,0,0,0,41,9,114, + 4,0,0,0,114,99,0,0,0,114,138,0,0,0,218,9, + 95,119,97,114,110,105,110,103,115,218,4,119,97,114,110,218, + 18,68,101,112,114,101,99,97,116,105,111,110,87,97,114,110, + 105,110,103,114,16,0,0,0,114,15,0,0,0,114,137,0, + 0,0,41,2,114,88,0,0,0,114,89,0,0,0,114,10, + 0,0,0,114,10,0,0,0,114,11,0,0,0,218,16,109, + 111,100,117,108,101,95,102,114,111,109,95,115,112,101,99,58, + 2,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,144,0,0, + 0,99,1,0,0,0,0,0,0,0,2,0,0,0,3,0, + 0,0,67,0,0,0,115,149,0,0,0,124,0,0,106,0, + 0,100,1,0,107,8,0,114,21,0,100,2,0,110,6,0, + 124,0,0,106,0,0,125,1,0,124,0,0,106,1,0,100, + 1,0,107,8,0,114,95,0,124,0,0,106,2,0,100,1, + 0,107,8,0,114,73,0,100,3,0,106,3,0,124,1,0, + 131,1,0,83,100,4,0,106,3,0,124,1,0,124,0,0, + 106,2,0,131,2,0,83,110,50,0,124,0,0,106,4,0, + 114,123,0,100,5,0,106,3,0,124,1,0,124,0,0,106, + 1,0,131,2,0,83,100,6,0,106,3,0,124,0,0,106, + 0,0,124,0,0,106,1,0,131,2,0,83,100,1,0,83, + 41,7,122,38,82,101,116,117,114,110,32,116,104,101,32,114, + 101,112,114,32,116,111,32,117,115,101,32,102,111,114,32,116, + 104,101,32,109,111,100,117,108,101,46,78,114,93,0,0,0, + 122,13,60,109,111,100,117,108,101,32,123,33,114,125,62,122, + 20,60,109,111,100,117,108,101,32,123,33,114,125,32,40,123, + 33,114,125,41,62,122,23,60,109,111,100,117,108,101,32,123, + 33,114,125,32,102,114,111,109,32,123,33,114,125,62,122,18, + 60,109,111,100,117,108,101,32,123,33,114,125,32,40,123,125, + 41,62,41,5,114,15,0,0,0,114,107,0,0,0,114,99, + 0,0,0,114,50,0,0,0,114,117,0,0,0,41,2,114, + 88,0,0,0,114,15,0,0,0,114,10,0,0,0,114,10, + 0,0,0,114,11,0,0,0,114,97,0,0,0,76,2,0, + 0,115,16,0,0,0,0,3,30,1,15,1,15,1,13,2, + 22,2,9,1,19,2,114,97,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,253,0,0,0,124,0,0,106,0,0,125,2,0,116,1, + 0,106,2,0,131,0,0,1,116,3,0,124,2,0,131,1, + 0,143,208,0,1,116,4,0,106,5,0,106,6,0,124,2, + 0,131,1,0,124,1,0,107,9,0,114,89,0,100,1,0, + 106,7,0,124,2,0,131,1,0,125,3,0,116,8,0,124, + 3,0,100,2,0,124,2,0,131,1,1,130,1,0,124,0, + 0,106,9,0,100,3,0,107,8,0,114,163,0,124,0,0, + 106,10,0,100,3,0,107,8,0,114,140,0,116,8,0,100, + 4,0,100,2,0,124,0,0,106,0,0,131,1,1,130,1, + 0,116,11,0,124,0,0,124,1,0,100,5,0,100,6,0, + 131,2,1,1,124,1,0,83,116,11,0,124,0,0,124,1, + 0,100,5,0,100,6,0,131,2,1,1,116,12,0,124,0, + 0,106,9,0,100,7,0,131,2,0,115,219,0,124,0,0, + 106,9,0,106,13,0,124,2,0,131,1,0,1,110,16,0, + 124,0,0,106,9,0,106,14,0,124,1,0,131,1,0,1, + 87,100,3,0,81,82,88,116,4,0,106,5,0,124,2,0, + 25,83,41,8,122,51,69,120,101,99,117,116,101,32,116,104, + 101,32,115,112,101,99,32,105,110,32,97,110,32,101,120,105, + 115,116,105,110,103,32,109,111,100,117,108,101,39,115,32,110, + 97,109,101,115,112,97,99,101,46,122,30,109,111,100,117,108, + 101,32,123,33,114,125,32,110,111,116,32,105,110,32,115,121, + 115,46,109,111,100,117,108,101,115,114,15,0,0,0,78,122, + 14,109,105,115,115,105,110,103,32,108,111,97,100,101,114,114, + 133,0,0,0,84,114,139,0,0,0,41,15,114,15,0,0, + 0,114,57,0,0,0,218,12,97,99,113,117,105,114,101,95, + 108,111,99,107,114,54,0,0,0,114,14,0,0,0,114,21, + 0,0,0,114,42,0,0,0,114,50,0,0,0,114,77,0, + 0,0,114,99,0,0,0,114,110,0,0,0,114,137,0,0, + 0,114,4,0,0,0,218,11,108,111,97,100,95,109,111,100, + 117,108,101,114,139,0,0,0,41,4,114,88,0,0,0,114, + 89,0,0,0,114,15,0,0,0,218,3,109,115,103,114,10, + 0,0,0,114,10,0,0,0,114,11,0,0,0,114,86,0, + 0,0,93,2,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,23,1,114,86,0,0,0, + 99,1,0,0,0,0,0,0,0,2,0,0,0,27,0,0, + 0,67,0,0,0,115,3,1,0,0,124,0,0,106,0,0, + 106,1,0,124,0,0,106,2,0,131,1,0,1,116,3,0, + 106,4,0,124,0,0,106,2,0,25,125,1,0,116,5,0, + 124,1,0,100,1,0,100,0,0,131,3,0,100,0,0,107, + 8,0,114,96,0,121,16,0,124,0,0,106,0,0,124,1, + 0,95,6,0,87,110,18,0,4,116,7,0,107,10,0,114, + 95,0,1,1,1,89,110,1,0,88,116,5,0,124,1,0, + 100,2,0,100,0,0,131,3,0,100,0,0,107,8,0,114, + 197,0,121,56,0,124,1,0,106,8,0,124,1,0,95,9, + 0,116,10,0,124,1,0,100,3,0,131,2,0,115,175,0, + 124,0,0,106,2,0,106,11,0,100,4,0,131,1,0,100, + 5,0,25,124,1,0,95,9,0,87,110,18,0,4,116,7, + 0,107,10,0,114,196,0,1,1,1,89,110,1,0,88,116, + 5,0,124,1,0,100,6,0,100,0,0,131,3,0,100,0, + 0,107,8,0,114,255,0,121,13,0,124,0,0,124,1,0, + 95,12,0,87,110,18,0,4,116,7,0,107,10,0,114,254, + 0,1,1,1,89,110,1,0,88,124,1,0,83,41,7,78, + 114,91,0,0,0,114,134,0,0,0,114,131,0,0,0,114, + 121,0,0,0,114,33,0,0,0,114,95,0,0,0,41,13, + 114,99,0,0,0,114,146,0,0,0,114,15,0,0,0,114, + 14,0,0,0,114,21,0,0,0,114,6,0,0,0,114,91, + 0,0,0,114,96,0,0,0,114,1,0,0,0,114,134,0, + 0,0,114,4,0,0,0,114,122,0,0,0,114,95,0,0, + 0,41,2,114,88,0,0,0,114,89,0,0,0,114,10,0, + 0,0,114,10,0,0,0,114,11,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,118,2,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,148,0,0,0,99,1,0, + 0,0,0,0,0,0,2,0,0,0,11,0,0,0,67,0, + 0,0,115,159,0,0,0,124,0,0,106,0,0,100,0,0, + 107,9,0,114,43,0,116,1,0,124,0,0,106,0,0,100, + 1,0,131,2,0,115,43,0,116,2,0,124,0,0,131,1, + 0,83,116,3,0,124,0,0,131,1,0,125,1,0,116,4, + 0,124,1,0,131,1,0,143,75,0,1,124,0,0,106,0, + 0,100,0,0,107,8,0,114,122,0,124,0,0,106,5,0, + 100,0,0,107,8,0,114,138,0,116,6,0,100,2,0,100, + 3,0,124,0,0,106,7,0,131,1,1,130,1,0,110,16, + 0,124,0,0,106,0,0,106,8,0,124,1,0,131,1,0, + 1,87,100,0,0,81,82,88,116,9,0,106,10,0,124,0, + 0,106,7,0,25,83,41,4,78,114,139,0,0,0,122,14, + 109,105,115,115,105,110,103,32,108,111,97,100,101,114,114,15, + 0,0,0,41,11,114,99,0,0,0,114,4,0,0,0,114, + 148,0,0,0,114,144,0,0,0,114,102,0,0,0,114,110, + 0,0,0,114,77,0,0,0,114,15,0,0,0,114,139,0, + 0,0,114,14,0,0,0,114,21,0,0,0,41,2,114,88, + 0,0,0,114,89,0,0,0,114,10,0,0,0,114,10,0, + 0,0,114,11,0,0,0,218,14,95,108,111,97,100,95,117, + 110,108,111,99,107,101,100,147,2,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,23,5,114,149,0,0,0,99,1,0,0,0,0,0, + 0,0,1,0,0,0,9,0,0,0,67,0,0,0,115,47, + 0,0,0,116,0,0,106,1,0,131,0,0,1,116,2,0, + 124,0,0,106,3,0,131,1,0,143,15,0,1,116,4,0, + 124,0,0,131,1,0,83,87,100,1,0,81,82,88,100,1, + 0,83,41,2,122,191,82,101,116,117,114,110,32,97,32,110, + 101,119,32,109,111,100,117,108,101,32,111,98,106,101,99,116, + 44,32,108,111,97,100,101,100,32,98,121,32,116,104,101,32, + 115,112,101,99,39,115,32,108,111,97,100,101,114,46,10,10, + 32,32,32,32,84,104,101,32,109,111,100,117,108,101,32,105, + 115,32,110,111,116,32,97,100,100,101,100,32,116,111,32,105, + 116,115,32,112,97,114,101,110,116,46,10,10,32,32,32,32, + 73,102,32,97,32,109,111,100,117,108,101,32,105,115,32,97, + 108,114,101,97,100,121,32,105,110,32,115,121,115,46,109,111, + 100,117,108,101,115,44,32,116,104,97,116,32,101,120,105,115, + 116,105,110,103,32,109,111,100,117,108,101,32,103,101,116,115, + 10,32,32,32,32,99,108,111,98,98,101,114,101,100,46,10, + 10,32,32,32,32,78,41,5,114,57,0,0,0,114,145,0, + 0,0,114,54,0,0,0,114,15,0,0,0,114,149,0,0, + 0,41,1,114,88,0,0,0,114,10,0,0,0,114,10,0, + 0,0,114,11,0,0,0,114,87,0,0,0,170,2,0,0, + 115,6,0,0,0,0,9,10,1,16,1,114,87,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,205,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,6, + 0,100,4,0,100,4,0,100,5,0,100,6,0,132,2,0, + 131,1,0,90,7,0,101,6,0,100,4,0,100,7,0,100, + 8,0,132,1,0,131,1,0,90,8,0,101,6,0,100,9, + 0,100,10,0,132,0,0,131,1,0,90,9,0,101,6,0, + 100,11,0,100,12,0,132,0,0,131,1,0,90,10,0,101, + 6,0,101,11,0,100,13,0,100,14,0,132,0,0,131,1, + 0,131,1,0,90,12,0,101,6,0,101,11,0,100,15,0, + 100,16,0,132,0,0,131,1,0,131,1,0,90,13,0,101, + 6,0,101,11,0,100,17,0,100,18,0,132,0,0,131,1, + 0,131,1,0,90,14,0,101,6,0,101,15,0,131,1,0, + 90,16,0,100,4,0,83,41,19,218,15,66,117,105,108,116, + 105,110,73,109,112,111,114,116,101,114,122,144,77,101,116,97, + 32,112,97,116,104,32,105,109,112,111,114,116,32,102,111,114, + 32,98,117,105,108,116,45,105,110,32,109,111,100,117,108,101, + 115,46,10,10,32,32,32,32,65,108,108,32,109,101,116,104, + 111,100,115,32,97,114,101,32,101,105,116,104,101,114,32,99, + 108,97,115,115,32,111,114,32,115,116,97,116,105,99,32,109, + 101,116,104,111,100,115,32,116,111,32,97,118,111,105,100,32, + 116,104,101,32,110,101,101,100,32,116,111,10,32,32,32,32, + 105,110,115,116,97,110,116,105,97,116,101,32,116,104,101,32, + 99,108,97,115,115,46,10,10,32,32,32,32,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,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,24,60, + 109,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,50,0,0,0,114,1, + 0,0,0,41,1,114,89,0,0,0,114,10,0,0,0,114, + 10,0,0,0,114,11,0,0,0,114,92,0,0,0,195,2, + 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,0,0,0,5,0,0,0,67,0,0,0,115,58,0,0, + 0,124,2,0,100,0,0,107,9,0,114,16,0,100,0,0, + 83,116,0,0,106,1,0,124,1,0,131,1,0,114,50,0, + 116,2,0,124,1,0,124,0,0,100,1,0,100,2,0,131, + 2,1,83,100,0,0,83,100,0,0,83,41,3,78,114,107, + 0,0,0,122,8,98,117,105,108,116,45,105,110,41,3,114, + 57,0,0,0,90,10,105,115,95,98,117,105,108,116,105,110, + 114,85,0,0,0,41,4,218,3,99,108,115,114,78,0,0, + 0,218,4,112,97,116,104,218,6,116,97,114,103,101,116,114, + 10,0,0,0,114,10,0,0,0,114,11,0,0,0,218,9, + 102,105,110,100,95,115,112,101,99,204,2,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,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,9,0,114,37,0,124, + 3,0,106,1,0,83,100,1,0,83,41,2,122,175,70,105, + 110,100,32,116,104,101,32,98,117,105,108,116,45,105,110,32, + 109,111,100,117,108,101,46,10,10,32,32,32,32,32,32,32, + 32,73,102,32,39,112,97,116,104,39,32,105,115,32,101,118, + 101,114,32,115,112,101,99,105,102,105,101,100,32,116,104,101, + 110,32,116,104,101,32,115,101,97,114,99,104,32,105,115,32, + 99,111,110,115,105,100,101,114,101,100,32,97,32,102,97,105, + 108,117,114,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,154,0,0,0,114,99,0,0,0,41,4,114,151,0,0, + 0,114,78,0,0,0,114,152,0,0,0,114,88,0,0,0, + 114,10,0,0,0,114,10,0,0,0,114,11,0,0,0,218, + 11,102,105,110,100,95,109,111,100,117,108,101,213,2,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,2, + 0,0,0,4,0,0,0,67,0,0,0,115,67,0,0,0, + 124,1,0,106,0,0,116,1,0,106,2,0,107,7,0,114, + 51,0,116,3,0,100,1,0,106,4,0,124,1,0,106,0, + 0,131,1,0,100,2,0,124,1,0,106,0,0,131,1,1, + 130,1,0,116,5,0,116,6,0,106,7,0,124,1,0,131, + 2,0,83,41,3,122,24,67,114,101,97,116,101,32,97,32, + 98,117,105,108,116,45,105,110,32,109,111,100,117,108,101,122, + 29,123,33,114,125,32,105,115,32,110,111,116,32,97,32,98, + 117,105,108,116,45,105,110,32,109,111,100,117,108,101,114,15, + 0,0,0,41,8,114,15,0,0,0,114,14,0,0,0,114, + 76,0,0,0,114,77,0,0,0,114,50,0,0,0,114,65, + 0,0,0,114,57,0,0,0,90,14,99,114,101,97,116,101, + 95,98,117,105,108,116,105,110,41,2,114,19,0,0,0,114, + 88,0,0,0,114,10,0,0,0,114,10,0,0,0,114,11, + 0,0,0,114,138,0,0,0,225,2,0,0,115,8,0,0, + 0,0,3,18,1,21,1,12,1,122,29,66,117,105,108,116, + 105,110,73,109,112,111,114,116,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,3,0,0,0,67,0,0,0,115,20,0, + 0,0,116,0,0,116,1,0,106,2,0,124,1,0,131,2, + 0,1,100,1,0,83,41,2,122,22,69,120,101,99,32,97, + 32,98,117,105,108,116,45,105,110,32,109,111,100,117,108,101, + 78,41,3,114,65,0,0,0,114,57,0,0,0,90,12,101, + 120,101,99,95,98,117,105,108,116,105,110,41,2,114,19,0, + 0,0,114,89,0,0,0,114,10,0,0,0,114,10,0,0, + 0,114,11,0,0,0,114,139,0,0,0,233,2,0,0,115, + 2,0,0,0,0,3,122,27,66,117,105,108,116,105,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,0,0, + 1,0,0,0,67,0,0,0,115,4,0,0,0,100,1,0, + 83,41,2,122,57,82,101,116,117,114,110,32,78,111,110,101, + 32,97,115,32,98,117,105,108,116,45,105,110,32,109,111,100, + 117,108,101,115,32,100,111,32,110,111,116,32,104,97,118,101, + 32,99,111,100,101,32,111,98,106,101,99,116,115,46,78,114, + 10,0,0,0,41,2,114,151,0,0,0,114,78,0,0,0, + 114,10,0,0,0,114,10,0,0,0,114,11,0,0,0,218, + 8,103,101,116,95,99,111,100,101,238,2,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,1,0,0,0,67, - 0,0,0,115,4,0,0,0,100,1,0,83,41,2,122,57, + 0,0,0,115,4,0,0,0,100,1,0,83,41,2,122,56, 82,101,116,117,114,110,32,78,111,110,101,32,97,115,32,98, 117,105,108,116,45,105,110,32,109,111,100,117,108,101,115,32, - 100,111,32,110,111,116,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,12,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,19,5,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,1,0,0,0,67,0,0,0,115,4, - 0,0,0,100,1,0,83,41,2,122,56,82,101,116,117,114, - 110,32,78,111,110,101,32,97,115,32,98,117,105,108,116,45, - 105,110,32,109,111,100,117,108,101,115,32,100,111,32,110,111, - 116,32,104,97,118,101,32,115,111,117,114,99,101,32,99,111, - 100,101,46,78,114,4,0,0,0,41,2,114,12,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, - 25,5,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,0,0,67,0,0,0,115,4,0,0, - 0,100,1,0,83,41,2,122,52,82,101,116,117,114,110,32, - 70,97,108,115,101,32,97,115,32,98,117,105,108,116,45,105, - 110,32,109,111,100,117,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,12,1,0,0,114,159,0,0,0,114, - 4,0,0,0,114,4,0,0,0,114,5,0,0,0,114,220, - 0,0,0,31,5,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,114,58,0,0,0,114,59,0,0,0, - 218,12,115,116,97,116,105,99,109,101,116,104,111,100,114,206, - 0,0,0,218,11,99,108,97,115,115,109,101,116,104,111,100, - 114,14,1,0,0,114,15,1,0,0,114,162,0,0,0,114, - 5,1,0,0,114,16,1,0,0,114,17,1,0,0,114,220, - 0,0,0,114,4,0,0,0,114,4,0,0,0,114,4,0, - 0,0,114,5,0,0,0,114,11,1,0,0,224,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,11,1,0,0,99,0,0,0,0,0,0,0,0,0, - 0,0,0,5,0,0,0,64,0,0,0,115,193,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,6,0,100,4,0,100,4,0,100,5,0, - 100,6,0,132,2,0,131,1,0,90,7,0,101,6,0,100, - 4,0,100,7,0,100,8,0,132,1,0,131,1,0,90,8, - 0,101,4,0,100,9,0,100,10,0,132,0,0,131,1,0, - 90,9,0,101,6,0,100,11,0,100,12,0,132,0,0,131, - 1,0,90,10,0,101,6,0,101,11,0,100,13,0,100,14, - 0,132,0,0,131,1,0,131,1,0,90,12,0,101,6,0, - 101,11,0,100,15,0,100,16,0,132,0,0,131,1,0,131, - 1,0,90,13,0,101,6,0,101,11,0,100,17,0,100,18, - 0,132,0,0,131,1,0,131,1,0,90,14,0,100,4,0, - 83,41,19,218,14,70,114,111,122,101,110,73,109,112,111,114, - 116,101,114,122,142,77,101,116,97,32,112,97,116,104,32,105, - 109,112,111,114,116,32,102,111,114,32,102,114,111,122,101,110, - 32,109,111,100,117,108,101,115,46,10,10,32,32,32,32,65, - 108,108,32,109,101,116,104,111,100,115,32,97,114,101,32,101, - 105,116,104,101,114,32,99,108,97,115,115,32,111,114,32,115, - 116,97,116,105,99,32,109,101,116,104,111,100,115,32,116,111, - 32,97,118,111,105,100,32,116,104,101,32,110,101,101,100,32, - 116,111,10,32,32,32,32,105,110,115,116,97,110,116,105,97, - 116,101,32,116,104,101,32,99,108,97,115,115,46,10,10,32, - 32,32,32,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,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,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,206,0,0, - 0,47,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,109,111,100, - 117,108,101,95,114,101,112,114,78,99,4,0,0,0,0,0, - 0,0,4,0,0,0,5,0,0,0,67,0,0,0,115,42, + 100,111,32,110,111,116,32,104,97,118,101,32,115,111,117,114, + 99,101,32,99,111,100,101,46,78,114,10,0,0,0,41,2, + 114,151,0,0,0,114,78,0,0,0,114,10,0,0,0,114, + 10,0,0,0,114,11,0,0,0,218,10,103,101,116,95,115, + 111,117,114,99,101,244,2,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,0,0,67,0,0, + 0,115,4,0,0,0,100,1,0,83,41,2,122,52,82,101, + 116,117,114,110,32,70,97,108,115,101,32,97,115,32,98,117, + 105,108,116,45,105,110,32,109,111,100,117,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,10,0,0,0,41,2,114,151,0,0,0,114, + 78,0,0,0,114,10,0,0,0,114,10,0,0,0,114,11, + 0,0,0,114,109,0,0,0,250,2,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, + 17,114,1,0,0,0,114,0,0,0,0,114,2,0,0,0, + 114,3,0,0,0,218,12,115,116,97,116,105,99,109,101,116, + 104,111,100,114,92,0,0,0,218,11,99,108,97,115,115,109, + 101,116,104,111,100,114,154,0,0,0,114,155,0,0,0,114, + 138,0,0,0,114,139,0,0,0,114,81,0,0,0,114,156, + 0,0,0,114,157,0,0,0,114,109,0,0,0,114,90,0, + 0,0,114,146,0,0,0,114,10,0,0,0,114,10,0,0, + 0,114,10,0,0,0,114,11,0,0,0,114,150,0,0,0, + 186,2,0,0,115,30,0,0,0,12,7,6,2,18,9,3, + 1,21,8,3,1,18,11,18,8,18,5,3,1,21,5,3, + 1,21,5,3,1,21,5,114,150,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,211,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,6,0,100,4,0, + 100,4,0,100,5,0,100,6,0,132,2,0,131,1,0,90, + 7,0,101,6,0,100,4,0,100,7,0,100,8,0,132,1, + 0,131,1,0,90,8,0,101,6,0,100,9,0,100,10,0, + 132,0,0,131,1,0,90,9,0,101,4,0,100,11,0,100, + 12,0,132,0,0,131,1,0,90,10,0,101,6,0,100,13, + 0,100,14,0,132,0,0,131,1,0,90,11,0,101,6,0, + 101,12,0,100,15,0,100,16,0,132,0,0,131,1,0,131, + 1,0,90,13,0,101,6,0,101,12,0,100,17,0,100,18, + 0,132,0,0,131,1,0,131,1,0,90,14,0,101,6,0, + 101,12,0,100,19,0,100,20,0,132,0,0,131,1,0,131, + 1,0,90,15,0,100,4,0,83,41,21,218,14,70,114,111, + 122,101,110,73,109,112,111,114,116,101,114,122,142,77,101,116, + 97,32,112,97,116,104,32,105,109,112,111,114,116,32,102,111, + 114,32,102,114,111,122,101,110,32,109,111,100,117,108,101,115, + 46,10,10,32,32,32,32,65,108,108,32,109,101,116,104,111, + 100,115,32,97,114,101,32,101,105,116,104,101,114,32,99,108, + 97,115,115,32,111,114,32,115,116,97,116,105,99,32,109,101, + 116,104,111,100,115,32,116,111,32,97,118,111,105,100,32,116, + 104,101,32,110,101,101,100,32,116,111,10,32,32,32,32,105, + 110,115,116,97,110,116,105,97,116,101,32,116,104,101,32,99, + 108,97,115,115,46,10,10,32,32,32,32,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,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,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,50,0,0,0,114,1,0,0,0, + 41,1,218,1,109,114,10,0,0,0,114,10,0,0,0,114, + 11,0,0,0,114,92,0,0,0,12,3,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,0,0,5,0, + 0,0,67,0,0,0,115,42,0,0,0,116,0,0,106,1, + 0,124,1,0,131,1,0,114,34,0,116,2,0,124,1,0, + 124,0,0,100,1,0,100,2,0,131,2,1,83,100,0,0, + 83,100,0,0,83,41,3,78,114,107,0,0,0,90,6,102, + 114,111,122,101,110,41,3,114,57,0,0,0,114,82,0,0, + 0,114,85,0,0,0,41,4,114,151,0,0,0,114,78,0, + 0,0,114,152,0,0,0,114,153,0,0,0,114,10,0,0, + 0,114,10,0,0,0,114,11,0,0,0,114,154,0,0,0, + 21,3,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,0,0,115,23, 0,0,0,116,0,0,106,1,0,124,1,0,131,1,0,114, - 34,0,116,2,0,124,1,0,124,0,0,100,1,0,100,2, - 0,131,2,1,83,100,0,0,83,100,0,0,83,41,3,78, - 114,218,0,0,0,90,6,102,114,111,122,101,110,41,3,114, - 106,0,0,0,114,163,0,0,0,114,174,0,0,0,41,4, - 114,12,1,0,0,114,159,0,0,0,114,35,0,0,0,114, - 13,1,0,0,114,4,0,0,0,114,4,0,0,0,114,5, - 0,0,0,114,14,1,0,0,56,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,0,0,115,23,0,0,0,116,0,0,106,1, - 0,124,1,0,131,1,0,114,19,0,124,0,0,83,100,1, - 0,83,41,2,122,93,70,105,110,100,32,97,32,102,114,111, - 122,101,110,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,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,106,0,0,0,114,163,0,0,0, - 41,3,114,12,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,15,1,0,0,63,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,1,0,0, - 0,0,0,0,0,3,0,0,0,4,0,0,0,67,0,0, - 0,115,95,0,0,0,124,0,0,106,0,0,106,1,0,125, - 1,0,116,2,0,106,3,0,124,1,0,131,1,0,115,57, - 0,116,4,0,100,1,0,106,5,0,124,1,0,131,1,0, - 100,2,0,124,1,0,131,1,1,130,1,0,110,0,0,116, - 6,0,116,2,0,106,7,0,124,1,0,131,2,0,125,2, - 0,116,8,0,124,2,0,124,0,0,106,9,0,131,2,0, - 1,100,0,0,83,41,3,78,122,27,123,33,114,125,32,105, - 115,32,110,111,116,32,97,32,102,114,111,122,101,110,32,109, - 111,100,117,108,101,114,67,0,0,0,41,10,114,209,0,0, - 0,114,67,0,0,0,114,106,0,0,0,114,163,0,0,0, - 114,154,0,0,0,114,47,0,0,0,114,114,0,0,0,218, - 17,103,101,116,95,102,114,111,122,101,110,95,111,98,106,101, - 99,116,114,176,0,0,0,114,63,0,0,0,41,3,114,180, - 0,0,0,114,67,0,0,0,114,195,0,0,0,114,4,0, - 0,0,114,4,0,0,0,114,5,0,0,0,114,2,1,0, - 0,72,5,0,0,115,12,0,0,0,0,2,12,1,15,1, - 18,1,12,1,18,1,122,26,70,114,111,122,101,110,73,109, + 19,0,124,0,0,83,100,1,0,83,41,2,122,93,70,105, + 110,100,32,97,32,102,114,111,122,101,110,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,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,57, + 0,0,0,114,82,0,0,0,41,3,114,151,0,0,0,114, + 78,0,0,0,114,152,0,0,0,114,10,0,0,0,114,10, + 0,0,0,114,11,0,0,0,114,155,0,0,0,28,3,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,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,10,0,0,0,41,2,114,151,0,0,0,114,88,0, + 0,0,114,10,0,0,0,114,10,0,0,0,114,11,0,0, + 0,114,138,0,0,0,37,3,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,0,0,67,0, + 0,0,115,92,0,0,0,124,0,0,106,0,0,106,1,0, + 125,1,0,116,2,0,106,3,0,124,1,0,131,1,0,115, + 54,0,116,4,0,100,1,0,106,5,0,124,1,0,131,1, + 0,100,2,0,124,1,0,131,1,1,130,1,0,116,6,0, + 116,2,0,106,7,0,124,1,0,131,2,0,125,2,0,116, + 8,0,124,2,0,124,0,0,106,9,0,131,2,0,1,100, + 0,0,83,41,3,78,122,27,123,33,114,125,32,105,115,32, + 110,111,116,32,97,32,102,114,111,122,101,110,32,109,111,100, + 117,108,101,114,15,0,0,0,41,10,114,95,0,0,0,114, + 15,0,0,0,114,57,0,0,0,114,82,0,0,0,114,77, + 0,0,0,114,50,0,0,0,114,65,0,0,0,218,17,103, + 101,116,95,102,114,111,122,101,110,95,111,98,106,101,99,116, + 218,4,101,120,101,99,114,7,0,0,0,41,3,114,89,0, + 0,0,114,15,0,0,0,218,4,99,111,100,101,114,10,0, + 0,0,114,10,0,0,0,114,11,0,0,0,114,139,0,0, + 0,41,3,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,0,0,3, 0,0,0,67,0,0,0,115,13,0,0,0,116,0,0,124, @@ -2267,10 +1456,10 @@ const unsigned char _Py_M__importlib[] = { 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,1,114,181, - 0,0,0,41,2,114,12,1,0,0,114,159,0,0,0,114, - 4,0,0,0,114,4,0,0,0,114,5,0,0,0,114,5, - 1,0,0,81,5,0,0,115,2,0,0,0,0,7,122,26, + 100,46,10,10,32,32,32,32,32,32,32,32,41,1,114,90, + 0,0,0,41,2,114,151,0,0,0,114,78,0,0,0,114, + 10,0,0,0,114,10,0,0,0,114,11,0,0,0,114,146, + 0,0,0,50,3,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,0,0,115, @@ -2278,9 +1467,9 @@ const unsigned char _Py_M__importlib[] = { 83,41,1,122,45,82,101,116,117,114,110,32,116,104,101,32, 99,111,100,101,32,111,98,106,101,99,116,32,102,111,114,32, 116,104,101,32,102,114,111,122,101,110,32,109,111,100,117,108, - 101,46,41,2,114,106,0,0,0,114,22,1,0,0,41,2, - 114,12,1,0,0,114,159,0,0,0,114,4,0,0,0,114, - 4,0,0,0,114,5,0,0,0,114,16,1,0,0,90,5, + 101,46,41,2,114,57,0,0,0,114,162,0,0,0,41,2, + 114,151,0,0,0,114,78,0,0,0,114,10,0,0,0,114, + 10,0,0,0,114,11,0,0,0,114,156,0,0,0,59,3, 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, @@ -2288,10 +1477,10 @@ const unsigned char _Py_M__importlib[] = { 41,2,122,54,82,101,116,117,114,110,32,78,111,110,101,32, 97,115,32,102,114,111,122,101,110,32,109,111,100,117,108,101, 115,32,100,111,32,110,111,116,32,104,97,118,101,32,115,111, - 117,114,99,101,32,99,111,100,101,46,78,114,4,0,0,0, - 41,2,114,12,1,0,0,114,159,0,0,0,114,4,0,0, - 0,114,4,0,0,0,114,5,0,0,0,114,17,1,0,0, - 96,5,0,0,115,2,0,0,0,0,4,122,25,70,114,111, + 117,114,99,101,32,99,111,100,101,46,78,114,10,0,0,0, + 41,2,114,151,0,0,0,114,78,0,0,0,114,10,0,0, + 0,114,10,0,0,0,114,11,0,0,0,114,157,0,0,0, + 65,3,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,0,0,0, @@ -2299,2079 +1488,501 @@ const unsigned char _Py_M__importlib[] = { 46,82,101,116,117,114,110,32,84,114,117,101,32,105,102,32, 116,104,101,32,102,114,111,122,101,110,32,109,111,100,117,108, 101,32,105,115,32,97,32,112,97,99,107,97,103,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,12,1,0,0, - 114,159,0,0,0,114,4,0,0,0,114,4,0,0,0,114, - 5,0,0,0,114,220,0,0,0,102,5,0,0,115,2,0, + 2,114,57,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,151,0,0,0, + 114,78,0,0,0,114,10,0,0,0,114,10,0,0,0,114, + 11,0,0,0,114,109,0,0,0,71,3,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, - 15,114,57,0,0,0,114,56,0,0,0,114,58,0,0,0, - 114,59,0,0,0,114,18,1,0,0,114,206,0,0,0,114, - 19,1,0,0,114,14,1,0,0,114,15,1,0,0,114,2, - 1,0,0,114,5,1,0,0,114,165,0,0,0,114,16,1, - 0,0,114,17,1,0,0,114,220,0,0,0,114,4,0,0, - 0,114,4,0,0,0,114,4,0,0,0,114,5,0,0,0, - 114,20,1,0,0,38,5,0,0,115,28,0,0,0,12,7, - 6,2,18,9,3,1,21,6,3,1,18,8,18,9,18,9, - 3,1,21,5,3,1,21,5,3,1,114,20,1,0,0,99, - 0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0, - 64,0,0,0,115,121,0,0,0,101,0,0,90,1,0,100, - 0,0,90,2,0,100,1,0,90,3,0,100,2,0,90,4, - 0,100,3,0,90,5,0,100,4,0,90,6,0,101,7,0, - 100,5,0,100,6,0,132,0,0,131,1,0,90,8,0,101, - 7,0,100,7,0,100,8,0,132,0,0,131,1,0,90,9, - 0,101,7,0,100,9,0,100,9,0,100,10,0,100,11,0, - 132,2,0,131,1,0,90,10,0,101,7,0,100,9,0,100, - 12,0,100,13,0,132,1,0,131,1,0,90,11,0,100,9, - 0,83,41,14,218,21,87,105,110,100,111,119,115,82,101,103, - 105,115,116,114,121,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,109,111,100,117,108,101,115,32,100,101,99,108,97,114, - 101,100,32,105,110,32,116,104,101,32,87,105,110,100,111,119, - 115,32,114,101,103,105,115,116,114,121,46,122,59,83,111,102, - 116,119,97,114,101,92,80,121,116,104,111,110,92,80,121,116, - 104,111,110,67,111,114,101,92,123,115,121,115,95,118,101,114, - 115,105,111,110,125,92,77,111,100,117,108,101,115,92,123,102, - 117,108,108,110,97,109,101,125,122,65,83,111,102,116,119,97, - 114,101,92,80,121,116,104,111,110,92,80,121,116,104,111,110, - 67,111,114,101,92,123,115,121,115,95,118,101,114,115,105,111, - 110,125,92,77,111,100,117,108,101,115,92,123,102,117,108,108, - 110,97,109,101,125,92,68,101,98,117,103,70,99,2,0,0, - 0,0,0,0,0,2,0,0,0,11,0,0,0,67,0,0, - 0,115,67,0,0,0,121,23,0,116,0,0,106,1,0,116, - 0,0,106,2,0,124,1,0,131,2,0,83,87,110,37,0, - 4,116,3,0,107,10,0,114,62,0,1,1,1,116,0,0, - 106,1,0,116,0,0,106,4,0,124,1,0,131,2,0,83, - 89,110,1,0,88,100,0,0,83,41,1,78,41,5,218,7, - 95,119,105,110,114,101,103,90,7,79,112,101,110,75,101,121, - 90,17,72,75,69,89,95,67,85,82,82,69,78,84,95,85, - 83,69,82,114,40,0,0,0,90,18,72,75,69,89,95,76, - 79,67,65,76,95,77,65,67,72,73,78,69,41,2,114,12, - 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,121,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,0,6,0,0,0,16,0,0,0,67, - 0,0,0,115,142,0,0,0,124,0,0,106,0,0,114,21, - 0,124,0,0,106,1,0,125,2,0,110,9,0,124,0,0, - 106,2,0,125,2,0,124,2,0,106,3,0,100,1,0,124, - 1,0,100,2,0,116,4,0,106,5,0,100,0,0,100,3, - 0,133,2,0,25,131,0,2,125,3,0,121,46,0,124,0, - 0,106,6,0,124,3,0,131,1,0,143,25,0,125,4,0, - 116,7,0,106,8,0,124,4,0,100,4,0,131,2,0,125, - 5,0,87,100,0,0,81,88,87,110,22,0,4,116,9,0, - 107,10,0,114,137,0,1,1,1,100,0,0,83,89,110,1, - 0,88,124,5,0,83,41,5,78,114,159,0,0,0,90,11, - 115,121,115,95,118,101,114,115,105,111,110,114,137,0,0,0, - 114,30,0,0,0,41,10,218,11,68,69,66,85,71,95,66, - 85,73,76,68,218,18,82,69,71,73,83,84,82,89,95,75, - 69,89,95,68,69,66,85,71,218,12,82,69,71,73,83,84, - 82,89,95,75,69,89,114,47,0,0,0,114,7,0,0,0, - 218,7,118,101,114,115,105,111,110,114,26,1,0,0,114,24, - 1,0,0,90,10,81,117,101,114,121,86,97,108,117,101,114, - 40,0,0,0,41,6,114,12,1,0,0,114,159,0,0,0, - 90,12,114,101,103,105,115,116,114,121,95,107,101,121,114,25, - 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,128,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,110,100,101,114,46,95,115,101,97,114, - 99,104,95,114,101,103,105,115,116,114,121,78,99,4,0,0, - 0,0,0,0,0,8,0,0,0,14,0,0,0,67,0,0, - 0,115,155,0,0,0,124,0,0,106,0,0,124,1,0,131, - 1,0,125,4,0,124,4,0,100,0,0,107,8,0,114,31, - 0,100,0,0,83,121,14,0,116,1,0,124,4,0,131,1, - 0,1,87,110,22,0,4,116,2,0,107,10,0,114,69,0, - 1,1,1,100,0,0,83,89,110,1,0,88,120,78,0,116, - 3,0,131,0,0,68,93,67,0,92,2,0,125,5,0,125, - 6,0,124,4,0,106,4,0,116,5,0,124,6,0,131,1, - 0,131,1,0,114,80,0,116,6,0,124,1,0,124,5,0, - 124,1,0,124,4,0,131,2,0,100,1,0,124,4,0,131, - 2,1,125,7,0,124,7,0,83,113,80,0,87,100,0,0, - 83,41,2,78,114,218,0,0,0,41,7,114,32,1,0,0, - 114,39,0,0,0,114,40,0,0,0,114,241,0,0,0,114, - 231,0,0,0,114,232,0,0,0,114,174,0,0,0,41,8, - 114,12,1,0,0,114,159,0,0,0,114,35,0,0,0,114, - 13,1,0,0,114,31,1,0,0,114,170,0,0,0,114,126, - 0,0,0,114,178,0,0,0,114,4,0,0,0,114,4,0, - 0,0,114,5,0,0,0,114,14,1,0,0,143,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,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,45,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,9,0,114,37,0,124,3,0,106,1,0,83,100,1,0, - 83,100,1,0,83,41,2,122,108,70,105,110,100,32,109,111, - 100,117,108,101,32,110,97,109,101,100,32,105,110,32,116,104, - 101,32,114,101,103,105,115,116,114,121,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,78,41,2,114,14,1,0,0,114,170,0, - 0,0,41,4,114,12,1,0,0,114,159,0,0,0,114,35, - 0,0,0,114,178,0,0,0,114,4,0,0,0,114,4,0, - 0,0,114,5,0,0,0,114,15,1,0,0,158,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,0,114,56,0,0,0,114,58,0,0, - 0,114,59,0,0,0,114,29,1,0,0,114,28,1,0,0, - 114,27,1,0,0,114,19,1,0,0,114,26,1,0,0,114, - 32,1,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,23,1,0,0,109,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,23,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,52, - 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,83,41,7,218,13,95,76,111,97,100, - 101,114,66,97,115,105,99,115,122,83,66,97,115,101,32,99, - 108,97,115,115,32,111,102,32,99,111,109,109,111,110,32,99, - 111,100,101,32,110,101,101,100,101,100,32,98,121,32,98,111, - 116,104,32,83,111,117,114,99,101,76,111,97,100,101,114,32, - 97,110,100,10,32,32,32,32,83,111,117,114,99,101,108,101, - 115,115,70,105,108,101,76,111,97,100,101,114,46,99,2,0, - 0,0,0,0,0,0,5,0,0,0,3,0,0,0,67,0, - 0,0,115,88,0,0,0,116,0,0,124,0,0,106,1,0, - 124,1,0,131,1,0,131,1,0,100,1,0,25,125,2,0, - 124,2,0,106,2,0,100,2,0,100,1,0,131,2,0,100, - 3,0,25,125,3,0,124,1,0,106,3,0,100,2,0,131, - 1,0,100,4,0,25,125,4,0,124,3,0,100,5,0,107, - 2,0,111,87,0,124,4,0,100,5,0,107,3,0,83,41, - 6,122,141,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,105,115,95,112, - 97,99,107,97,103,101,32,98,121,32,99,104,101,99,107,105, - 110,103,32,105,102,10,32,32,32,32,32,32,32,32,116,104, - 101,32,112,97,116,104,32,114,101,116,117,114,110,101,100,32, - 98,121,32,103,101,116,95,102,105,108,101,110,97,109,101,32, - 104,97,115,32,97,32,102,105,108,101,110,97,109,101,32,111, - 102,32,39,95,95,105,110,105,116,95,95,46,112,121,39,46, - 114,29,0,0,0,114,116,0,0,0,114,84,0,0,0,114, - 115,0,0,0,114,72,0,0,0,41,4,114,38,0,0,0, - 114,239,0,0,0,114,34,0,0,0,114,32,0,0,0,41, - 5,114,71,0,0,0,114,159,0,0,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,220,0,0,0,177,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,3,0,0,0,4,0,0,0,67,0,0,0,115,80, - 0,0,0,124,0,0,106,0,0,124,1,0,106,1,0,131, - 1,0,125,2,0,124,2,0,100,1,0,107,8,0,114,57, - 0,116,2,0,100,2,0,106,3,0,124,1,0,106,1,0, - 131,1,0,131,1,0,130,1,0,110,0,0,116,4,0,116, - 5,0,124,2,0,124,1,0,106,6,0,131,3,0,1,100, - 1,0,83,41,3,122,19,69,120,101,99,117,116,101,32,116, - 104,101,32,109,111,100,117,108,101,46,78,122,52,99,97,110, - 110,111,116,32,108,111,97,100,32,109,111,100,117,108,101,32, - 123,33,114,125,32,119,104,101,110,32,103,101,116,95,99,111, - 100,101,40,41,32,114,101,116,117,114,110,115,32,78,111,110, - 101,41,7,114,16,1,0,0,114,57,0,0,0,114,154,0, - 0,0,114,47,0,0,0,114,114,0,0,0,114,176,0,0, - 0,114,63,0,0,0,41,3,114,71,0,0,0,114,180,0, - 0,0,114,195,0,0,0,114,4,0,0,0,114,4,0,0, - 0,114,5,0,0,0,114,2,1,0,0,185,5,0,0,115, - 10,0,0,0,0,2,18,1,12,1,9,1,18,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,8,114,57,0,0, - 0,114,56,0,0,0,114,58,0,0,0,114,59,0,0,0, - 114,220,0,0,0,114,2,1,0,0,114,181,0,0,0,114, - 5,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,172,5,0, - 0,115,8,0,0,0,12,3,6,2,12,8,12,8,114,33, - 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,0,0, - 90,1,0,100,0,0,90,2,0,100,1,0,100,2,0,132, - 0,0,90,3,0,100,3,0,100,4,0,132,0,0,90,4, - 0,100,5,0,100,6,0,132,0,0,90,5,0,100,7,0, - 100,8,0,132,0,0,90,6,0,100,9,0,100,10,0,132, - 0,0,90,7,0,100,11,0,100,18,0,100,13,0,100,14, - 0,132,0,1,90,8,0,100,15,0,100,16,0,132,0,0, - 90,9,0,100,17,0,83,41,19,218,12,83,111,117,114,99, - 101,76,111,97,100,101,114,99,2,0,0,0,0,0,0,0, - 2,0,0,0,1,0,0,0,67,0,0,0,115,10,0,0, - 0,116,0,0,130,1,0,100,1,0,83,41,2,122,178,79, - 112,116,105,111,110,97,108,32,109,101,116,104,111,100,32,116, - 104,97,116,32,114,101,116,117,114,110,115,32,116,104,101,32, - 109,111,100,105,102,105,99,97,116,105,111,110,32,116,105,109, - 101,32,40,97,110,32,105,110,116,41,32,102,111,114,32,116, - 104,101,10,32,32,32,32,32,32,32,32,115,112,101,99,105, - 102,105,101,100,32,112,97,116,104,44,32,119,104,101,114,101, - 32,112,97,116,104,32,105,115,32,97,32,115,116,114,46,10, - 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,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,198,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,184,0,0,0,41,1,114,36, - 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,206,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,219,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,38,1,0,0,229,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,239,0,0,0,218,8,103,101,116,95,100,97,116,97, - 114,40,0,0,0,114,154,0,0,0,114,204,0,0,0,41, - 5,114,71,0,0,0,114,159,0,0,0,114,35,0,0,0, - 114,202,0,0,0,218,3,101,120,99,114,4,0,0,0,114, - 4,0,0,0,114,5,0,0,0,114,17,1,0,0,236,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,176,0, - 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,42,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,246,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,177,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,173,1, - 124,4,0,100,1,0,107,9,0,114,173,1,124,3,0,100, - 1,0,107,9,0,114,173,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,113,173,1,4,116,2,0,107,10,0,114,169, - 1,1,1,1,89,113,173,1,88,110,0,0,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,184,0,0,0,114,188,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,239,0,0,0,114,132,0,0,0,114,123,0, - 0,0,114,37,1,0,0,114,35,1,0,0,114,14,0,0, - 0,114,40,1,0,0,114,40,0,0,0,114,191,0,0,0, - 114,154,0,0,0,114,187,0,0,0,114,153,0,0,0,114, - 196,0,0,0,114,45,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,199,0,0,0,114,31,0,0,0,114,39,1, - 0,0,41,10,114,71,0,0,0,114,159,0,0,0,114,142, - 0,0,0,114,189,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,202,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,16,1,0,0,254,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,8,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,36,1, - 0,0,114,37,1,0,0,114,39,1,0,0,114,38,1,0, - 0,114,17,1,0,0,114,45,1,0,0,114,16,1,0,0, - 114,4,0,0,0,114,4,0,0,0,114,4,0,0,0,114, - 5,0,0,0,114,34,1,0,0,196,5,0,0,115,14,0, - 0,0,12,2,12,8,12,13,12,10,12,7,12,10,18,8, - 114,34,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,55,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,225,0,0,0,114, - 63,0,0,0,41,2,114,71,0,0,0,114,228,0,0,0, - 114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,114, - 230,0,0,0,61,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,65,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,49, - 1,0,0,114,5,1,0,0,41,2,114,71,0,0,0,114, - 159,0,0,0,41,1,114,225,0,0,0,114,4,0,0,0, - 114,5,0,0,0,114,5,1,0,0,68,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,239, - 0,0,0,80,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,40,1,0,0, - 85,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,230,0, - 0,0,114,51,1,0,0,114,157,0,0,0,114,5,1,0, - 0,114,239,0,0,0,114,40,1,0,0,114,4,0,0,0, - 114,4,0,0,0,41,1,114,225,0,0,0,114,5,0,0, - 0,114,49,1,0,0,50,6,0,0,115,14,0,0,0,12, - 3,6,2,12,6,12,4,12,3,24,12,18,5,114,49,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,9, - 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,184,0,0,0,114,185,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,47,1,0,0,114,4,0,0,0, - 114,4,0,0,0,114,5,0,0,0,114,37,1,0,0,95, - 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,38,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,39,1,0,0,100,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,55,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,224,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,55,1,0,0,114,234,0,0,0,114, - 131,0,0,0,114,27,0,0,0,114,23,0,0,0,114,41, - 1,0,0,114,4,0,0,0,114,4,0,0,0,114,5,0, - 0,0,114,38,1,0,0,105,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,37,1,0,0,114,39,1, - 0,0,114,38,1,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, - 91,6,0,0,115,8,0,0,0,12,2,6,2,12,5,12, - 5,114,9,1,0,0,99,0,0,0,0,0,0,0,0,0, + 16,114,1,0,0,0,114,0,0,0,0,114,2,0,0,0, + 114,3,0,0,0,114,158,0,0,0,114,92,0,0,0,114, + 159,0,0,0,114,154,0,0,0,114,155,0,0,0,114,138, + 0,0,0,114,139,0,0,0,114,146,0,0,0,114,84,0, + 0,0,114,156,0,0,0,114,157,0,0,0,114,109,0,0, + 0,114,10,0,0,0,114,10,0,0,0,114,10,0,0,0, + 114,11,0,0,0,114,160,0,0,0,3,3,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,160,0,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,8,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,239, - 0,0,0,114,40,1,0,0,114,191,0,0,0,114,196,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,48,1,0,0,114,4,0, - 0,0,114,4,0,0,0,114,5,0,0,0,114,16,1,0, - 0,138,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,17,1,0,0, - 144,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,16,1,0,0,114,17,1,0,0,114,4,0, - 0,0,114,4,0,0,0,114,4,0,0,0,114,5,0,0, - 0,114,8,1,0,0,134,6,0,0,115,6,0,0,0,12, - 2,6,2,12,6,114,8,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, - 161,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,225,0,0, - 0,114,63,0,0,0,41,2,114,71,0,0,0,114,228,0, - 0,0,114,4,0,0,0,114,4,0,0,0,114,5,0,0, - 0,114,230,0,0,0,165,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,50,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,51,1, - 0,0,169,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,183,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,124,0,116,7,0,124,2,0,100,3,0,131,2, - 0,12,114,124,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,110,0, - 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,179,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,110,0,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,247,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,220,0,0,0,114,60,0,0,0,114, - 38,0,0,0,114,247,0,0,0,114,205,0,0,0,114,57, - 0,0,0,114,251,0,0,0,114,32,0,0,0,41,4,114, - 71,0,0,0,114,159,0,0,0,114,180,0,0,0,114,220, - 0,0,0,114,4,0,0,0,114,4,0,0,0,114,5,0, - 0,0,114,5,1,0,0,172,6,0,0,115,24,0,0,0, - 0,5,13,1,9,1,21,1,16,1,15,1,22,1,28,1, - 9,1,12,1,6,1,28,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,193,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,59,1,0,0,114,5,0,0,0,114,220, - 0,0,0,190,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,16,1,0,0,196,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,17,1,0,0,200, - 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,239,0,0,0, - 204,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,230,0,0,0,114,51, - 1,0,0,114,157,0,0,0,114,5,1,0,0,114,220,0, - 0,0,114,16,1,0,0,114,17,1,0,0,114,239,0,0, - 0,114,4,0,0,0,114,4,0,0,0,114,4,0,0,0, - 114,5,0,0,0,114,57,1,0,0,153,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,57,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,254,0,0,0, - 114,232,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,217,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,247,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,234, - 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,223,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,67,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,62,1,0,0,233,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,127,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,120,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,108,0, - 124,2,0,106,5,0,100,0,0,107,8,0,114,108,0,124, - 2,0,106,6,0,114,108,0,124,2,0,106,6,0,124,0, - 0,95,7,0,113,108,0,110,0,0,124,1,0,124,0,0, - 95,2,0,110,0,0,124,0,0,106,7,0,83,41,1,78, - 41,8,114,232,0,0,0,114,62,1,0,0,114,63,1,0, - 0,114,64,1,0,0,114,70,0,0,0,114,170,0,0,0, - 114,221,0,0,0,114,254,0,0,0,41,3,114,71,0,0, - 0,90,11,112,97,114,101,110,116,95,112,97,116,104,114,178, - 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, - 237,6,0,0,115,16,0,0,0,0,2,18,1,15,1,21, - 3,27,1,9,1,18,1,12,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,68,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, - 250,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,68,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,253,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,254,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,0,7,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,68,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,3,7,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,254,0,0,0,114,224,0,0,0, - 41,2,114,71,0,0,0,114,72,1,0,0,114,4,0,0, - 0,114,4,0,0,0,114,5,0,0,0,114,224,0,0,0, - 6,7,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,67, - 1,0,0,114,62,1,0,0,114,68,1,0,0,114,70,1, - 0,0,114,71,1,0,0,114,101,0,0,0,114,73,1,0, - 0,114,224,0,0,0,114,4,0,0,0,114,4,0,0,0, - 114,4,0,0,0,114,5,0,0,0,114,61,1,0,0,210, - 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,61,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,106,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,83,41,16,114,252,0,0,0,99,4,0,0, + 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,57,0,0,0,114,145,0,0,0,41,1,114,19,0, + 0,0,114,10,0,0,0,114,10,0,0,0,114,11,0,0, + 0,114,23,0,0,0,84,3,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,57,0,0,0,114, + 58,0,0,0,41,4,114,19,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, + 10,0,0,0,114,10,0,0,0,114,11,0,0,0,114,30, + 0,0,0,88,3,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,1, + 0,0,0,114,0,0,0,0,114,2,0,0,0,114,3,0, + 0,0,114,23,0,0,0,114,30,0,0,0,114,10,0,0, + 0,114,10,0,0,0,114,10,0,0,0,114,11,0,0,0, + 114,165,0,0,0,80,3,0,0,115,6,0,0,0,12,2, + 6,2,12,4,114,165,0,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,121,0,0,0,114,45,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, + 33,0,0,0,122,5,123,125,46,123,125,41,4,218,6,114, + 115,112,108,105,116,218,3,108,101,110,218,10,86,97,108,117, + 101,69,114,114,111,114,114,50,0,0,0,41,5,114,15,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,90,4,98,97,115,101,114,10, + 0,0,0,114,10,0,0,0,114,11,0,0,0,218,13,95, + 114,101,115,111,108,118,101,95,110,97,109,101,93,3,0,0, + 115,10,0,0,0,0,2,22,1,18,1,12,1,10,1,114, + 171,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,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,155,0,0,0,114,85,0,0,0,41,4,218,6, + 102,105,110,100,101,114,114,15,0,0,0,114,152,0,0,0, + 114,99,0,0,0,114,10,0,0,0,114,10,0,0,0,114, + 11,0,0,0,218,17,95,102,105,110,100,95,115,112,101,99, + 95,108,101,103,97,99,121,102,3,0,0,115,8,0,0,0, + 0,3,18,1,12,1,4,1,114,173,0,0,0,99,3,0, + 0,0,0,0,0,0,9,0,0,0,27,0,0,0,67,0, + 0,0,115,42,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, + 235,0,116,0,0,106,1,0,68,93,220,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,82,88,124,6,0,100,1,0,107,9,0,114,66, + 0,124,3,0,12,114,26,1,124,0,0,116,0,0,106,5, + 0,107,6,0,114,26,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,2,1,1,1, + 1,124,6,0,83,89,113,30,1,88,124,8,0,100,1,0, + 107,8,0,114,19,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,14,0,0,0,218,9,109,101, + 116,97,95,112,97,116,104,114,141,0,0,0,114,142,0,0, + 0,218,13,73,109,112,111,114,116,87,97,114,110,105,110,103, + 114,21,0,0,0,114,165,0,0,0,114,154,0,0,0,114, + 96,0,0,0,114,173,0,0,0,114,95,0,0,0,41,9, + 114,15,0,0,0,114,152,0,0,0,114,153,0,0,0,90, + 9,105,115,95,114,101,108,111,97,100,114,172,0,0,0,114, + 154,0,0,0,114,88,0,0,0,114,89,0,0,0,114,95, + 0,0,0,114,10,0,0,0,114,10,0,0,0,114,11,0, + 0,0,218,10,95,102,105,110,100,95,115,112,101,99,111,3, + 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,25, + 1,12,2,22,1,13,1,3,1,13,1,13,4,9,2,12, + 1,4,2,7,2,8,2,114,176,0,0,0,99,3,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,61,1,0,0,114,254,0,0,0,41,4, - 114,71,0,0,0,114,67,0,0,0,114,35,0,0,0,114, - 65,1,0,0,114,4,0,0,0,114,4,0,0,0,114,5, - 0,0,0,114,72,0,0,0,12,7,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,12,1,0,0,114,180,0, - 0,0,114,4,0,0,0,114,4,0,0,0,114,5,0,0, - 0,114,206,0,0,0,15,7,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,220,0,0,0,24,7,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,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,17,1,0,0,27,7,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,176,0,0,0,114,43,1,0,0,84,41,1, - 114,44,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,16,1,0,0,30,7,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,0,0,83,41,1,78,114,4,0,0, - 0,41,2,114,71,0,0,0,114,180,0,0,0,114,4,0, - 0,0,114,4,0,0,0,114,5,0,0,0,114,2,1,0, - 0,33,7,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,254,0,0,0,114,181,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,5,1,0,0, - 36,7,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,11,114,57, - 0,0,0,114,56,0,0,0,114,58,0,0,0,114,72,0, - 0,0,114,19,1,0,0,114,206,0,0,0,114,220,0,0, - 0,114,17,1,0,0,114,16,1,0,0,114,2,1,0,0, - 114,5,1,0,0,114,4,0,0,0,114,4,0,0,0,114, - 4,0,0,0,114,5,0,0,0,114,252,0,0,0,11,7, - 0,0,115,14,0,0,0,12,1,12,3,18,9,12,3,12, - 3,12,3,12,3,114,252,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,58,0,0,0,120,51,0,116, - 0,0,106,1,0,106,2,0,131,0,0,68,93,34,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,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,75,1,0,0,41,2,114,12,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,75,1,0,0,53,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,94, - 0,0,0,116,0,0,106,1,0,115,28,0,116,2,0,106, - 3,0,100,1,0,116,4,0,131,2,0,1,110,0,0,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,38,0, - 4,116,5,0,107,10,0,114,81,0,1,1,1,119,38,0, - 89,113,38,0,88,113,38,0,87,100,2,0,83,100,2,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,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,78, - 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,12,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,61,7,0,0,115,16,0,0,0,0,7, - 9,1,19,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,11,0,0,0,67,0,0,0,115,97,0,0,0, - 124,1,0,100,1,0,107,2,0,114,27,0,116,0,0,106, - 1,0,131,0,0,125,1,0,110,0,0,121,17,0,116,2, - 0,106,3,0,124,1,0,25,125,2,0,87,110,46,0,4, - 116,4,0,107,10,0,114,92,0,1,1,1,124,0,0,106, - 5,0,124,1,0,131,1,0,125,2,0,124,2,0,116,2, - 0,106,3,0,124,1,0,60,89,110,1,0,88,124,2,0, - 83,41,2,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,41,6,114,3, - 0,0,0,114,45,0,0,0,114,7,0,0,0,114,76,1, - 0,0,114,79,0,0,0,114,80,1,0,0,41,3,114,12, - 1,0,0,114,35,0,0,0,114,78,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,78,7,0,0,115,16,0,0,0,0,8,12,1,15, - 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,15,1,0,0, - 114,174,0,0,0,114,217,0,0,0,114,221,0,0,0,41, - 6,114,12,1,0,0,114,159,0,0,0,114,78,1,0,0, - 114,170,0,0,0,114,171,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, - 95,108,101,103,97,99,121,95,103,101,116,95,115,112,101,99, - 95,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,252, - 0,0,0,103,0,0,125,4,0,120,239,0,124,2,0,68, - 93,203,0,125,5,0,116,0,0,124,5,0,116,1,0,116, - 2,0,102,2,0,131,2,0,115,46,0,113,13,0,110,0, - 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,109,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,145,0,113,13, - 0,110,0,0,124,7,0,106,7,0,100,1,0,107,9,0, - 114,164,0,124,7,0,83,124,7,0,106,8,0,125,8,0, - 124,8,0,100,1,0,107,8,0,114,200,0,116,9,0,100, - 3,0,131,1,0,130,1,0,110,0,0,124,4,0,106,10, - 0,124,8,0,131,1,0,1,113,13,0,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,14,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, - 193,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,14,1,0,0,114, - 82,1,0,0,114,170,0,0,0,114,221,0,0,0,114,154, - 0,0,0,114,198,0,0,0,114,217,0,0,0,41,9,114, - 12,1,0,0,114,159,0,0,0,114,35,0,0,0,114,13, - 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,78,1,0,0,114, - 178,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,110,7,0,0,115,40,0,0,0,0,5,6,1, - 13,1,21,1,6,1,15,1,12,1,15,1,21,2,18,1, - 12,1,6,1,15,1,4,1,9,1,12,1,15,5,20,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, - 143,0,0,0,124,2,0,100,1,0,107,8,0,114,24,0, - 116,0,0,106,1,0,125,2,0,110,0,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,61,0,100,1,0, - 83,124,4,0,106,3,0,100,1,0,107,8,0,114,135,0, - 124,4,0,106,4,0,125,5,0,124,5,0,114,128,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,221,0,0,0, - 114,218,0,0,0,114,61,1,0,0,41,6,114,12,1,0, - 0,114,159,0,0,0,114,35,0,0,0,114,13,1,0,0, - 114,178,0,0,0,114,85,1,0,0,114,4,0,0,0,114, - 4,0,0,0,114,5,0,0,0,114,14,1,0,0,142,7, - 0,0,115,26,0,0,0,0,4,12,1,12,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,14,1,0,0, - 114,170,0,0,0,41,4,114,12,1,0,0,114,159,0,0, - 0,114,35,0,0,0,114,178,0,0,0,114,4,0,0,0, - 114,4,0,0,0,114,5,0,0,0,114,15,1,0,0,164, - 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,19, - 1,0,0,114,75,1,0,0,114,80,1,0,0,114,81,1, - 0,0,114,82,1,0,0,114,86,1,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,74,1,0,0,49, - 7,0,0,115,22,0,0,0,12,2,6,2,18,8,18,17, - 18,17,18,15,3,1,18,31,3,1,21,21,3,1,114,74, - 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,58,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,193, - 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,198,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,187,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,75,1,0, - 0,201,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,14,1,0,0, - 114,170,0,0,0,114,221,0,0,0,41,3,114,71,0,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,166,0,0,0,207, - 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,221,0,0,0,41,1,114,240,0,0,0,41,7, - 114,71,0,0,0,114,244,0,0,0,114,159,0,0,0,114, - 35,0,0,0,114,229,0,0,0,114,13,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,219,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,240,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,123,0,124,0,0,106, - 8,0,131,0,0,1,124,5,0,124,0,0,95,7,0,110, - 0,0,116,9,0,131,0,0,114,156,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,51,1,116,13, - 0,124,0,0,106,2,0,124,4,0,131,2,0,125,8,0, - 120,103,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,211,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,211,0,87,116,17,0,124,8, - 0,131,1,0,125,3,0,110,0,0,120,126,0,124,0,0, - 106,14,0,68,93,115,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,61,1,116, - 15,0,124,12,0,131,1,0,114,176,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,61,1,113,61,1,87,124,3,0,114,236, - 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,54,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,217,0,0, - 0,114,221,0,0,0,41,14,114,71,0,0,0,114,159,0, - 0,0,114,13,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,184,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,58,1,0,0,114,244,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,178,0,0,0, - 114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,114, - 14,1,0,0,224,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,12, - 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,15,2,22,1,22,1,25, - 1,16,1,12,1,32,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,14,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, - 10,1,100,4,0,100,5,0,132,0,0,124,2,0,68,131, - 1,0,124,0,0,95,17,0,110,0,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,42, - 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, - 218,17,70,105,108,101,78,111,116,70,111,117,110,100,69,114, - 114,111,114,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,72,1,0, - 0,114,67,0,0,0,114,66,1,0,0,114,58,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,13,8, - 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,46,0,0,0,116,0,0,124,0,0,131, - 1,0,115,33,0,116,1,0,100,1,0,100,2,0,124,0, - 0,131,1,1,130,1,0,110,0,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,12,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, - 54,8,0,0,115,6,0,0,0,0,2,12,1,21,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,12, - 1,0,0,114,93,1,0,0,114,100,1,0,0,114,4,0, - 0,0,41,2,114,12,1,0,0,114,93,1,0,0,114,5, - 0,0,0,218,9,112,97,116,104,95,104,111,111,107,44,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,62,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,75,1,0,0,114,173,0,0,0,114,15,1,0, - 0,114,166,0,0,0,114,86,1,0,0,114,14,1,0,0, - 114,94,1,0,0,114,19,1,0,0,114,101,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,178,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, - 4,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,72, - 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,76,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,102,1,0,0,68,8, - 0,0,115,6,0,0,0,12,2,6,2,12,4,114,102,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,91,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,55,0,116,2,0,100,3,0,131,1,0,130,1,0, - 110,0,0,124,3,0,100,4,0,25,125,4,0,124,0,0, - 114,87,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,81,8,0, - 0,115,10,0,0,0,0,2,22,1,18,1,15,1,10,1, - 114,105,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,15,1,0,0,114,174,0,0,0,41,4,114, - 78,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,90,8,0,0,115,8,0,0,0,0,3, - 18,1,12,1,4,1,114,106,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,34,1,0,0,116,0,0,106,1,0,115,28,0,116,2, - 0,106,3,0,100,1,0,116,4,0,131,2,0,1,110,0, - 0,124,0,0,116,0,0,106,5,0,107,6,0,125,3,0, - 120,240,0,116,0,0,106,1,0,68,93,225,0,125,4,0, - 116,6,0,131,0,0,143,93,0,1,121,13,0,124,4,0, - 106,7,0,125,5,0,87,110,54,0,4,116,8,0,107,10, - 0,114,138,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,2,0,107, - 8,0,114,134,0,119,53,0,110,0,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,2,0,81,88,124,6,0,100,2,0,107,9, - 0,114,53,0,124,3,0,12,114,15,1,124,0,0,116,0, - 0,106,5,0,107,6,0,114,15,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,247, - 0,1,1,1,124,6,0,83,89,113,19,1,88,124,8,0, - 100,2,0,107,8,0,114,8,1,124,6,0,83,124,8,0, - 83,113,22,1,124,6,0,83,113,53,0,113,53,0,87,100, - 2,0,83,100,2,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,122,22,115,121,115,46,109,101,116,97,95,112,97,116, - 104,32,105,115,32,101,109,112,116,121,78,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,102,1,0,0,114,14,1,0,0,114,210,0,0,0, - 114,106,1,0,0,114,209,0,0,0,41,9,114,67,0,0, - 0,114,35,0,0,0,114,13,1,0,0,90,9,105,115,95, - 114,101,108,111,97,100,114,78,1,0,0,114,14,1,0,0, - 114,178,0,0,0,114,180,0,0,0,114,209,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,99,8,0,0,115,48, - 0,0,0,0,2,9,1,19,4,15,1,16,1,10,1,3, - 1,13,1,13,1,18,1,12,1,11,2,24,1,12,2,22, - 1,13,1,3,1,13,1,13,4,9,2,12,1,4,2,7, - 2,11,2,114,108,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,194,0, - 0,0,116,0,0,124,0,0,116,1,0,131,2,0,115,45, - 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,110,0,0,124, - 2,0,100,2,0,107,0,0,114,72,0,116,5,0,100,3, - 0,131,1,0,130,1,0,110,0,0,124,1,0,114,156,0, - 116,0,0,124,1,0,116,1,0,131,2,0,115,108,0,116, - 2,0,100,4,0,131,1,0,130,1,0,113,156,0,124,1, - 0,116,6,0,106,7,0,107,7,0,114,156,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,113,156,0,110,0,0,124,0, - 0,12,114,190,0,124,2,0,100,2,0,107,2,0,114,190, - 0,116,5,0,100,6,0,131,1,0,130,1,0,110,0,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,193,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,103,1,0,0,114,104,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,139,8,0,0,115,24,0,0,0,0,2,15,1, - 30,1,12,1,15,1,6,1,15,1,15,1,15,1,6,2, - 27,1,19,1,114,111,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,52,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,178,0,124,3,0,116,1,0, - 106,2,0,107,7,0,114,62,0,116,3,0,124,1,0,124, - 3,0,131,2,0,1,110,0,0,124,0,0,116,1,0,106, - 2,0,107,6,0,114,88,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,113,178,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,130,1,0,89,113,178,0,88,110,0,0,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,235,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,18,0,116,10,0,124,6,0,131,1,0,106, - 11,0,131,0,0,125,7,0,124,3,0,114,48,1,116,1, - 0,106,2,0,124,3,0,25,125,4,0,116,12,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,110,0,0,124,7,0,83,41, - 6,78,114,116,0,0,0,114,84,0,0,0,122,23,59,32, + 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,33,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,218,10,105,115,105,110,115, + 116,97,110,99,101,218,3,115,116,114,218,9,84,121,112,101, + 69,114,114,111,114,114,50,0,0,0,114,13,0,0,0,114, + 168,0,0,0,114,14,0,0,0,114,21,0,0,0,218,11, + 83,121,115,116,101,109,69,114,114,111,114,41,4,114,15,0, + 0,0,114,169,0,0,0,114,170,0,0,0,114,147,0,0, + 0,114,10,0,0,0,114,10,0,0,0,114,11,0,0,0, + 218,13,95,115,97,110,105,116,121,95,99,104,101,99,107,151, + 3,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,181,0,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,121,0,0,0,114,33,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, - 13,114,32,0,0,0,114,7,0,0,0,114,73,0,0,0, - 114,114,0,0,0,114,247,0,0,0,114,210,0,0,0,218, - 8,95,69,82,82,95,77,83,71,114,47,0,0,0,114,154, - 0,0,0,114,108,1,0,0,114,175,0,0,0,114,7,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,234,0,0, - 0,90,13,112,97,114,101,110,116,95,109,111,100,117,108,101, - 114,172,0,0,0,114,178,0,0,0,114,180,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,159,8,0,0,115,42,0,0,0, - 0,1,6,1,19,1,6,1,15,1,16,2,15,1,11,1, - 13,1,3,1,13,1,13,1,22,1,26,1,15,1,12,1, - 30,2,18,1,6,2,13,1,32,1,114,114,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, - 114,1,0,0,41,2,114,67,0,0,0,114,113,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,186, - 8,0,0,115,4,0,0,0,0,2,13,1,114,115,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,172,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,49,0,116,1,0,124,0,0,124,1,0, - 124,2,0,131,3,0,125,0,0,110,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,87,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,158,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,110,0,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,111,1,0,0,114,105,1,0, - 0,114,106,0,0,0,114,4,1,0,0,114,7,0,0,0, - 114,73,0,0,0,114,115,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,103,1,0,0,114,104,1,0,0,114,180,0,0, - 0,114,152,0,0,0,114,4,0,0,0,114,4,0,0,0, - 114,5,0,0,0,114,116,1,0,0,192,8,0,0,115,28, - 0,0,0,0,9,16,1,12,1,21,1,10,1,15,1,13, - 1,13,1,12,1,10,1,6,1,9,1,21,1,10,1,114, - 116,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,1,1,0,0,116,0, - 0,124,0,0,100,1,0,131,2,0,114,253,0,100,2,0, - 124,1,0,107,6,0,114,89,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,89, - 0,124,1,0,106,3,0,124,0,0,106,4,0,131,1,0, - 1,113,89,0,110,0,0,120,161,0,124,1,0,68,93,150, - 0,125,3,0,116,0,0,124,0,0,124,3,0,131,2,0, - 115,96,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,246,0,4,116,8,0, - 107,10,0,114,242,0,1,125,5,0,1,122,53,0,116,9, - 0,124,5,0,131,1,0,106,10,0,116,11,0,131,1,0, - 114,221,0,124,5,0,106,12,0,124,4,0,107,2,0,114, - 221,0,119,96,0,113,221,0,110,0,0,130,0,0,87,89, - 100,5,0,100,5,0,125,5,0,126,5,0,88,113,246,0, - 88,113,96,0,113,96,0,87,110,0,0,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,247,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,246,0,0,0,218,6,114,101,109,111,118,101,114,198, - 0,0,0,114,118,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,180, - 0,0,0,218,8,102,114,111,109,108,105,115,116,114,113,1, - 0,0,114,16,0,0,0,90,9,102,114,111,109,95,110,97, - 109,101,114,41,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,216,8,0,0,115,34,0,0, - 0,0,10,15,1,12,1,12,1,13,1,15,1,22,1,13, - 1,15,1,21,1,3,1,17,1,18,4,21,1,15,1,9, - 1,32,1,114,122,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,78,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,74,0,124,0,0, - 100,3,0,25,125,1,0,100,4,0,124,0,0,107,7,0, - 114,74,0,124,1,0,106,1,0,100,5,0,131,1,0,100, - 6,0,25,125,1,0,113,74,0,110,0,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,251,0,0,0, - 78,114,57,0,0,0,114,247,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,103,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,248,8,0,0,115,12,0,0,0,0,7,15,1, - 12,1,10,1,12,1,25,1,114,124,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,57,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,9,1,0,0,114,135,0,0,0,114,8,1,0,0, - 114,233,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,241,0,0,0,7,9,0,0,115,8,0, - 0,0,0,5,18,1,12,1,12,1,114,241,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,116,1,0,0,114,124,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,122,1,0,0,41,9, - 114,67,0,0,0,114,123,1,0,0,218,6,108,111,99,97, - 108,115,114,121,1,0,0,114,104,1,0,0,114,180,0,0, - 0,90,8,103,108,111,98,97,108,115,95,114,103,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,18,9,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,127,1,0,0,99,1,0,0, + 99,107,97,103,101,114,15,0,0,0,114,140,0,0,0,41, + 12,114,122,0,0,0,114,14,0,0,0,114,21,0,0,0, + 114,65,0,0,0,114,131,0,0,0,114,96,0,0,0,218, + 8,95,69,82,82,95,77,83,71,114,50,0,0,0,114,77, + 0,0,0,114,176,0,0,0,114,149,0,0,0,114,5,0, + 0,0,41,8,114,15,0,0,0,218,7,105,109,112,111,114, + 116,95,114,152,0,0,0,114,123,0,0,0,90,13,112,97, + 114,101,110,116,95,109,111,100,117,108,101,114,147,0,0,0, + 114,88,0,0,0,114,89,0,0,0,114,10,0,0,0,114, + 10,0,0,0,114,11,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,171,3,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,184,0,0,0,99,2,0,0,0,0, + 0,0,0,2,0,0,0,10,0,0,0,67,0,0,0,115, + 37,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,82,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,54,0,0,0,114,184,0,0,0, + 41,2,114,15,0,0,0,114,183,0,0,0,114,10,0,0, + 0,114,10,0,0,0,114,11,0,0,0,218,14,95,102,105, + 110,100,95,97,110,100,95,108,111,97,100,198,3,0,0,115, + 4,0,0,0,0,2,13,1,114,185,0,0,0,114,33,0, + 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,33,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,15,0,0,0, + 41,12,114,181,0,0,0,114,171,0,0,0,114,57,0,0, + 0,114,145,0,0,0,114,14,0,0,0,114,21,0,0,0, + 114,185,0,0,0,218,11,95,103,99,100,95,105,109,112,111, + 114,116,114,58,0,0,0,114,50,0,0,0,114,77,0,0, + 0,114,63,0,0,0,41,5,114,15,0,0,0,114,169,0, + 0,0,114,170,0,0,0,114,89,0,0,0,114,74,0,0, + 0,114,10,0,0,0,114,10,0,0,0,114,11,0,0,0, + 114,186,0,0,0,204,3,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,186,0,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,131,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,4,0,0,0,114,130,0,0,0,218, + 6,114,101,109,111,118,101,218,6,101,120,116,101,110,100,114, + 188,0,0,0,114,50,0,0,0,114,1,0,0,0,114,65, + 0,0,0,114,77,0,0,0,114,178,0,0,0,114,71,0, + 0,0,218,15,95,69,82,82,95,77,83,71,95,80,82,69, + 70,73,88,114,15,0,0,0,41,6,114,89,0,0,0,218, + 8,102,114,111,109,108,105,115,116,114,183,0,0,0,218,1, + 120,90,9,102,114,111,109,95,110,97,109,101,90,3,101,120, + 99,114,10,0,0,0,114,10,0,0,0,114,11,0,0,0, + 218,16,95,104,97,110,100,108,101,95,102,114,111,109,108,105, + 115,116,228,3,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,194,0, + 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, + 134,0,0,0,78,114,1,0,0,0,114,131,0,0,0,114, + 121,0,0,0,114,33,0,0,0,41,2,114,42,0,0,0, + 114,122,0,0,0,41,2,218,7,103,108,111,98,97,108,115, + 114,169,0,0,0,114,10,0,0,0,114,10,0,0,0,114, + 11,0,0,0,218,17,95,99,97,108,99,95,95,95,112,97, + 99,107,97,103,101,95,95,4,4,0,0,115,12,0,0,0, + 0,7,15,1,12,1,10,1,12,1,19,1,114,196,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,33,0,0,0, + 78,114,121,0,0,0,41,8,114,186,0,0,0,114,196,0, + 0,0,218,9,112,97,114,116,105,116,105,111,110,114,167,0, + 0,0,114,14,0,0,0,114,21,0,0,0,114,1,0,0, + 0,114,194,0,0,0,41,9,114,15,0,0,0,114,195,0, + 0,0,218,6,108,111,99,97,108,115,114,192,0,0,0,114, + 170,0,0,0,114,89,0,0,0,90,8,103,108,111,98,97, + 108,115,95,114,169,0,0,0,90,7,99,117,116,95,111,102, + 102,114,10,0,0,0,114,10,0,0,0,114,11,0,0,0, + 218,10,95,95,105,109,112,111,114,116,95,95,19,4,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, + 199,0,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,150,0,0,0,114,154,0,0,0,114,77,0, + 0,0,114,149,0,0,0,41,2,114,15,0,0,0,114,88, + 0,0,0,114,10,0,0,0,114,10,0,0,0,114,11,0, + 0,0,218,18,95,98,117,105,108,116,105,110,95,102,114,111, + 109,95,110,97,109,101,54,4,0,0,115,8,0,0,0,0, + 1,15,1,12,1,16,1,114,200,0,0,0,99,2,0,0, + 0,0,0,0,0,12,0,0,0,12,0,0,0,67,0,0, + 0,115,74,1,0,0,124,1,0,97,0,0,124,0,0,97, + 1,0,116,2,0,116,1,0,131,1,0,125,2,0,120,123, + 0,116,1,0,106,3,0,106,4,0,131,0,0,68,93,106, + 0,92,2,0,125,3,0,125,4,0,116,5,0,124,4,0, + 124,2,0,131,2,0,114,40,0,124,3,0,116,1,0,106, + 6,0,107,6,0,114,91,0,116,7,0,125,5,0,110,27, + 0,116,0,0,106,8,0,124,3,0,131,1,0,114,40,0, + 116,9,0,125,5,0,110,3,0,113,40,0,116,10,0,124, + 4,0,124,5,0,131,2,0,125,6,0,116,11,0,124,6, + 0,124,4,0,131,2,0,1,113,40,0,87,116,1,0,106, + 3,0,116,12,0,25,125,7,0,120,73,0,100,5,0,68, + 93,65,0,125,8,0,124,8,0,116,1,0,106,3,0,107, + 7,0,114,206,0,116,13,0,124,8,0,131,1,0,125,9, + 0,110,13,0,116,1,0,106,3,0,124,8,0,25,125,9, + 0,116,14,0,124,7,0,124,8,0,124,9,0,131,3,0, + 1,113,170,0,87,121,16,0,116,13,0,100,2,0,131,1, + 0,125,10,0,87,110,24,0,4,116,15,0,107,10,0,114, + 25,1,1,1,1,100,3,0,125,10,0,89,110,1,0,88, + 116,14,0,124,7,0,100,2,0,124,10,0,131,3,0,1, + 116,13,0,100,4,0,131,1,0,125,11,0,116,14,0,124, + 7,0,100,4,0,124,11,0,131,3,0,1,100,3,0,83, + 41,6,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,141, + 0,0,0,114,34,0,0,0,78,114,62,0,0,0,41,1, + 122,9,95,119,97,114,110,105,110,103,115,41,16,114,57,0, + 0,0,114,14,0,0,0,114,13,0,0,0,114,21,0,0, + 0,218,5,105,116,101,109,115,114,177,0,0,0,114,76,0, + 0,0,114,150,0,0,0,114,82,0,0,0,114,160,0,0, + 0,114,132,0,0,0,114,137,0,0,0,114,1,0,0,0, + 114,200,0,0,0,114,5,0,0,0,114,77,0,0,0,41, + 12,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,15,0,0,0,114,89,0,0, + 0,114,99,0,0,0,114,88,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,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,114,10,0,0,0,114,10,0,0,0,114, + 11,0,0,0,218,6,95,115,101,116,117,112,61,4,0,0, + 115,50,0,0,0,0,9,6,1,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,3,1,16,1,13, + 2,11,1,16,3,12,1,114,204,0,0,0,99,2,0,0, 0,0,0,0,0,3,0,0,0,3,0,0,0,67,0,0, - 0,115,68,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,46, - 0,116,2,0,100,1,0,124,0,0,23,131,1,0,130,1, - 0,110,0,0,116,3,0,124,1,0,131,1,0,125,2,0, - 124,2,0,106,4,0,131,0,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,5,114,11,1,0,0,114, - 14,1,0,0,114,154,0,0,0,114,175,0,0,0,114,7, - 1,0,0,41,3,114,67,0,0,0,114,178,0,0,0,114, - 179,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,53,9,0,0,115,10,0,0,0, - 0,1,15,1,12,1,19,1,12,1,114,128,1,0,0,99, - 2,0,0,0,0,0,0,0,19,0,0,0,12,0,0,0, - 67,0,0,0,115,232,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,138,0,116, - 1,0,106,8,0,106,9,0,131,0,0,68,93,121,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,131, - 1,0,125,7,0,124,7,0,106,17,0,124,4,0,131,1, - 0,1,113,67,0,113,67,0,87,116,1,0,106,8,0,116, - 18,0,25,125,8,0,120,73,0,100,26,0,68,93,65,0, - 125,9,0,124,9,0,116,1,0,106,8,0,107,7,0,114, - 248,0,116,19,0,124,9,0,131,1,0,125,10,0,110,13, - 0,116,1,0,106,8,0,124,9,0,25,125,10,0,116,20, - 0,124,8,0,124,9,0,124,10,0,131,3,0,1,113,212, - 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,11,0,120,146,0,124,11,0,68,93,126,0,92,2,0, - 125,12,0,125,13,0,116,21,0,100,9,0,100,10,0,132, - 0,0,124,13,0,68,131,1,0,131,1,0,115,108,1,116, - 22,0,130,1,0,124,13,0,100,11,0,25,125,14,0,124, - 12,0,116,1,0,106,8,0,107,6,0,114,150,1,116,1, - 0,106,8,0,124,12,0,25,125,15,0,80,113,65,1,121, - 17,0,116,19,0,124,12,0,131,1,0,125,15,0,80,87, - 113,65,1,4,116,23,0,107,10,0,114,190,1,1,1,1, - 119,65,1,89,113,65,1,88,113,65,1,87,116,23,0,100, - 12,0,131,1,0,130,1,0,116,20,0,124,8,0,100,13, - 0,124,15,0,131,3,0,1,116,20,0,124,8,0,100,14, - 0,124,14,0,131,3,0,1,116,20,0,124,8,0,100,15, - 0,100,16,0,106,24,0,124,13,0,131,1,0,131,3,0, - 1,121,16,0,116,19,0,100,17,0,131,1,0,125,16,0, - 87,110,24,0,4,116,23,0,107,10,0,114,50,2,1,1, - 1,100,18,0,125,16,0,89,110,1,0,88,116,20,0,124, - 8,0,100,17,0,124,16,0,131,3,0,1,116,19,0,100, - 19,0,131,1,0,125,17,0,116,20,0,124,8,0,100,19, - 0,124,17,0,131,3,0,1,124,12,0,100,7,0,107,2, - 0,114,138,2,116,19,0,100,20,0,131,1,0,125,18,0, - 116,20,0,124,8,0,100,21,0,124,18,0,131,3,0,1, - 110,0,0,116,20,0,124,8,0,100,22,0,116,25,0,131, - 0,0,131,3,0,1,116,26,0,106,27,0,116,0,0,106, - 28,0,131,0,0,131,1,0,1,124,12,0,100,7,0,107, - 2,0,114,228,2,116,29,0,106,30,0,100,23,0,131,1, - 0,1,100,24,0,116,26,0,107,6,0,114,228,2,100,25, - 0,116,31,0,95,32,0,113,228,2,110,0,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,192,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,105,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,24,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,33,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,233, - 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,193,0,0,0,114,158, - 0,0,0,114,11,1,0,0,114,163,0,0,0,114,20,1, - 0,0,114,248,0,0,0,114,175,0,0,0,114,255,0,0, - 0,114,57,0,0,0,114,128,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,60,1,0,0,114,198, - 0,0,0,114,125,1,0,0,114,135,0,0,0,114,224,0, - 0,0,114,23,1,0,0,114,27,1,0,0,41,19,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,180,0,0,0,114,170, - 0,0,0,114,178,0,0,0,114,179,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,61,9,0,0,115,108, - 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,12,1,20,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,19,3,19,1,19,1,12,1,13,1,12,1,114, - 137,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,136,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,116,0,116, - 2,0,106,7,0,106,8,0,116,13,0,131,1,0,1,110, - 0,0,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,131,1,0, - 0,78,41,15,114,137,1,0,0,114,241,0,0,0,114,7, - 0,0,0,114,79,1,0,0,114,198,0,0,0,114,87,1, - 0,0,114,101,1,0,0,114,107,1,0,0,114,224,0,0, - 0,114,11,1,0,0,114,20,1,0,0,114,3,0,0,0, - 114,57,0,0,0,114,23,1,0,0,114,74,1,0,0,41, - 3,114,135,1,0,0,114,136,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,148,9,0,0,115,16,0,0,0, - 0,2,13,1,9,1,28,1,16,1,16,1,15,1,19,1, - 114,138,1,0,0,41,3,122,3,119,105,110,114,1,0,0, - 0,114,2,0,0,0,41,92,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,194,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,186, - 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,181,0,0,0,114,191,0,0,0,114,196,0,0,0, - 114,199,0,0,0,114,204,0,0,0,114,212,0,0,0,114, - 213,0,0,0,114,217,0,0,0,114,174,0,0,0,218,6, - 111,98,106,101,99,116,114,242,0,0,0,114,240,0,0,0, - 114,248,0,0,0,114,175,0,0,0,114,10,1,0,0,114, - 11,1,0,0,114,20,1,0,0,114,23,1,0,0,114,33, - 1,0,0,114,34,1,0,0,114,49,1,0,0,114,9,1, - 0,0,114,8,1,0,0,114,60,1,0,0,114,57,1,0, - 0,114,61,1,0,0,114,252,0,0,0,114,74,1,0,0, - 114,87,1,0,0,114,102,1,0,0,114,105,1,0,0,114, - 106,1,0,0,114,108,1,0,0,114,111,1,0,0,114,120, - 1,0,0,114,112,1,0,0,114,114,1,0,0,114,115,1, - 0,0,114,116,1,0,0,114,122,1,0,0,114,124,1,0, - 0,114,241,0,0,0,114,127,1,0,0,114,128,1,0,0, - 114,137,1,0,0,114,138,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,170,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,114,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, - 17,12,16,21,55,21,12,18,10,12,14,12,36,19,27,19, - 106,24,22,9,3,12,1,15,63,18,45,19,230,15,25,19, - 70,19,71,19,63,19,24,22,110,19,41,25,43,25,16,6, - 3,19,57,19,57,19,38,19,129,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,8,12,87, + 0,115,87,0,0,0,116,0,0,124,0,0,124,1,0,131, + 2,0,1,116,1,0,106,2,0,106,3,0,116,4,0,131, + 1,0,1,116,1,0,106,2,0,106,3,0,116,5,0,131, + 1,0,1,100,1,0,100,2,0,108,6,0,125,2,0,124, + 2,0,97,7,0,124,2,0,106,8,0,116,1,0,106,9, + 0,116,10,0,25,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,33,0,0,0,78,41,11,114,204,0,0,0, + 114,14,0,0,0,114,174,0,0,0,114,113,0,0,0,114, + 150,0,0,0,114,160,0,0,0,218,26,95,102,114,111,122, + 101,110,95,105,109,112,111,114,116,108,105,98,95,101,120,116, + 101,114,110,97,108,114,119,0,0,0,218,8,95,105,110,115, + 116,97,108,108,114,21,0,0,0,114,1,0,0,0,41,3, + 114,202,0,0,0,114,203,0,0,0,114,205,0,0,0,114, + 10,0,0,0,114,10,0,0,0,114,11,0,0,0,114,206, + 0,0,0,108,4,0,0,115,12,0,0,0,0,2,13,2, + 16,1,16,3,12,1,6,1,114,206,0,0,0,41,51,114, + 3,0,0,0,114,119,0,0,0,114,12,0,0,0,114,16, + 0,0,0,114,17,0,0,0,114,59,0,0,0,114,41,0, + 0,0,114,48,0,0,0,114,31,0,0,0,114,32,0,0, + 0,114,53,0,0,0,114,54,0,0,0,114,56,0,0,0, + 114,63,0,0,0,114,65,0,0,0,114,75,0,0,0,114, + 81,0,0,0,114,84,0,0,0,114,90,0,0,0,114,101, + 0,0,0,114,102,0,0,0,114,106,0,0,0,114,85,0, + 0,0,218,6,111,98,106,101,99,116,90,9,95,80,79,80, + 85,76,65,84,69,114,132,0,0,0,114,137,0,0,0,114, + 144,0,0,0,114,97,0,0,0,114,86,0,0,0,114,148, + 0,0,0,114,149,0,0,0,114,87,0,0,0,114,150,0, + 0,0,114,160,0,0,0,114,165,0,0,0,114,171,0,0, + 0,114,173,0,0,0,114,176,0,0,0,114,181,0,0,0, + 114,191,0,0,0,114,182,0,0,0,114,184,0,0,0,114, + 185,0,0,0,114,186,0,0,0,114,194,0,0,0,114,196, + 0,0,0,114,199,0,0,0,114,200,0,0,0,114,204,0, + 0,0,114,206,0,0,0,114,10,0,0,0,114,10,0,0, + 0,114,10,0,0,0,114,11,0,0,0,218,8,60,109,111, + 100,117,108,101,62,8,0,0,0,115,96,0,0,0,6,17, + 6,2,12,8,12,4,19,20,6,2,6,3,22,4,19,68, + 19,21,19,19,12,19,12,19,12,11,18,8,12,11,12,12, + 12,16,12,36,19,27,19,101,24,26,9,3,18,45,18,60, + 12,18,12,17,12,25,12,29,12,23,12,16,19,73,19,77, + 19,13,12,9,12,9,15,40,12,17,6,1,10,2,12,27, + 12,6,18,24,12,32,12,15,24,35,12,7,12,47, }; diff --git a/Python/importlib_external.h b/Python/importlib_external.h new file mode 100644 index 0000000000..b20ce1756d --- /dev/null +++ b/Python/importlib_external.h @@ -0,0 +1,2597 @@ +/* Auto-generated by Programs/_freeze_importlib.c */ +const unsigned char _Py_M__importlib_external[] = { + 99,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0, + 0,64,0,0,0,115,228,2,0,0,100,0,0,90,0,0, + 100,96,0,90,1,0,100,4,0,100,5,0,132,0,0,90, + 2,0,100,6,0,100,7,0,132,0,0,90,3,0,100,8, + 0,100,9,0,132,0,0,90,4,0,100,10,0,100,11,0, + 132,0,0,90,5,0,100,12,0,100,13,0,132,0,0,90, + 6,0,100,14,0,100,15,0,132,0,0,90,7,0,100,16, + 0,100,17,0,132,0,0,90,8,0,100,18,0,100,19,0, + 132,0,0,90,9,0,100,20,0,100,21,0,132,0,0,90, + 10,0,100,22,0,100,23,0,100,24,0,132,1,0,90,11, + 0,101,12,0,101,11,0,106,13,0,131,1,0,90,14,0, + 100,25,0,106,15,0,100,26,0,100,27,0,131,2,0,100, + 28,0,23,90,16,0,101,17,0,106,18,0,101,16,0,100, + 27,0,131,2,0,90,19,0,100,29,0,90,20,0,100,30, + 0,90,21,0,100,31,0,103,1,0,90,22,0,100,32,0, + 103,1,0,90,23,0,101,23,0,4,90,24,0,90,25,0, + 100,33,0,100,34,0,100,33,0,100,35,0,100,36,0,132, + 1,1,90,26,0,100,37,0,100,38,0,132,0,0,90,27, + 0,100,39,0,100,40,0,132,0,0,90,28,0,100,41,0, + 100,42,0,132,0,0,90,29,0,100,43,0,100,44,0,132, + 0,0,90,30,0,100,45,0,100,46,0,100,47,0,100,48, + 0,132,0,1,90,31,0,100,49,0,100,50,0,132,0,0, + 90,32,0,100,51,0,100,52,0,132,0,0,90,33,0,100, + 33,0,100,33,0,100,33,0,100,53,0,100,54,0,132,3, + 0,90,34,0,100,33,0,100,33,0,100,33,0,100,55,0, + 100,56,0,132,3,0,90,35,0,100,57,0,100,57,0,100, + 58,0,100,59,0,132,2,0,90,36,0,100,60,0,100,61, + 0,132,0,0,90,37,0,101,38,0,131,0,0,90,39,0, + 100,33,0,100,62,0,100,33,0,100,63,0,101,39,0,100, + 64,0,100,65,0,132,1,2,90,40,0,71,100,66,0,100, + 67,0,132,0,0,100,67,0,131,2,0,90,41,0,71,100, + 68,0,100,69,0,132,0,0,100,69,0,131,2,0,90,42, + 0,71,100,70,0,100,71,0,132,0,0,100,71,0,101,42, + 0,131,3,0,90,43,0,71,100,72,0,100,73,0,132,0, + 0,100,73,0,131,2,0,90,44,0,71,100,74,0,100,75, + 0,132,0,0,100,75,0,101,44,0,101,43,0,131,4,0, + 90,45,0,71,100,76,0,100,77,0,132,0,0,100,77,0, + 101,44,0,101,42,0,131,4,0,90,46,0,103,0,0,90, + 47,0,71,100,78,0,100,79,0,132,0,0,100,79,0,101, + 44,0,101,42,0,131,4,0,90,48,0,71,100,80,0,100, + 81,0,132,0,0,100,81,0,131,2,0,90,49,0,71,100, + 82,0,100,83,0,132,0,0,100,83,0,131,2,0,90,50, + 0,71,100,84,0,100,85,0,132,0,0,100,85,0,131,2, + 0,90,51,0,71,100,86,0,100,87,0,132,0,0,100,87, + 0,131,2,0,90,52,0,100,33,0,100,88,0,100,89,0, + 132,1,0,90,53,0,100,90,0,100,91,0,132,0,0,90, + 54,0,100,92,0,100,93,0,132,0,0,90,55,0,100,94, + 0,100,95,0,132,0,0,90,56,0,100,33,0,83,41,97, + 97,94,1,0,0,67,111,114,101,32,105,109,112,108,101,109, + 101,110,116,97,116,105,111,110,32,111,102,32,112,97,116,104, + 45,98,97,115,101,100,32,105,109,112,111,114,116,46,10,10, + 84,104,105,115,32,109,111,100,117,108,101,32,105,115,32,78, + 79,84,32,109,101,97,110,116,32,116,111,32,98,101,32,100, + 105,114,101,99,116,108,121,32,105,109,112,111,114,116,101,100, + 33,32,73,116,32,104,97,115,32,98,101,101,110,32,100,101, + 115,105,103,110,101,100,32,115,117,99,104,10,116,104,97,116, + 32,105,116,32,99,97,110,32,98,101,32,98,111,111,116,115, + 116,114,97,112,112,101,100,32,105,110,116,111,32,80,121,116, + 104,111,110,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,32,65,115,10,115,117,99,104,32,105,116,32, + 114,101,113,117,105,114,101,115,32,116,104,101,32,105,110,106, + 101,99,116,105,111,110,32,111,102,32,115,112,101,99,105,102, + 105,99,32,109,111,100,117,108,101,115,32,97,110,100,32,97, + 116,116,114,105,98,117,116,101,115,32,105,110,32,111,114,100, + 101,114,32,116,111,10,119,111,114,107,46,32,79,110,101,32, + 115,104,111,117,108,100,32,117,115,101,32,105,109,112,111,114, + 116,108,105,98,32,97,115,32,116,104,101,32,112,117,98,108, + 105,99,45,102,97,99,105,110,103,32,118,101,114,115,105,111, + 110,32,111,102,32,116,104,105,115,32,109,111,100,117,108,101, + 46,10,10,218,3,119,105,110,218,6,99,121,103,119,105,110, + 218,6,100,97,114,119,105,110,99,0,0,0,0,0,0,0, + 0,1,0,0,0,2,0,0,0,67,0,0,0,115,49,0, + 0,0,116,0,0,106,1,0,106,2,0,116,3,0,131,1, + 0,114,33,0,100,1,0,100,2,0,132,0,0,125,0,0, + 110,12,0,100,3,0,100,2,0,132,0,0,125,0,0,124, + 0,0,83,41,4,78,99,0,0,0,0,0,0,0,0,0, + 0,0,0,2,0,0,0,83,0,0,0,115,13,0,0,0, + 100,1,0,116,0,0,106,1,0,107,6,0,83,41,2,122, + 53,84,114,117,101,32,105,102,32,102,105,108,101,110,97,109, + 101,115,32,109,117,115,116,32,98,101,32,99,104,101,99,107, + 101,100,32,99,97,115,101,45,105,110,115,101,110,115,105,116, + 105,118,101,108,121,46,115,12,0,0,0,80,89,84,72,79, + 78,67,65,83,69,79,75,41,2,218,3,95,111,115,90,7, + 101,110,118,105,114,111,110,169,0,114,4,0,0,0,114,4, + 0,0,0,250,38,60,102,114,111,122,101,110,32,105,109,112, + 111,114,116,108,105,98,46,95,98,111,111,116,115,116,114,97, + 112,95,101,120,116,101,114,110,97,108,62,218,11,95,114,101, + 108,97,120,95,99,97,115,101,30,0,0,0,115,2,0,0, + 0,0,2,122,37,95,109,97,107,101,95,114,101,108,97,120, + 95,99,97,115,101,46,60,108,111,99,97,108,115,62,46,95, + 114,101,108,97,120,95,99,97,115,101,99,0,0,0,0,0, + 0,0,0,0,0,0,0,1,0,0,0,83,0,0,0,115, + 4,0,0,0,100,1,0,83,41,2,122,53,84,114,117,101, + 32,105,102,32,102,105,108,101,110,97,109,101,115,32,109,117, + 115,116,32,98,101,32,99,104,101,99,107,101,100,32,99,97, + 115,101,45,105,110,115,101,110,115,105,116,105,118,101,108,121, + 46,70,114,4,0,0,0,114,4,0,0,0,114,4,0,0, + 0,114,4,0,0,0,114,5,0,0,0,114,6,0,0,0, + 34,0,0,0,115,2,0,0,0,0,2,41,4,218,3,115, + 121,115,218,8,112,108,97,116,102,111,114,109,218,10,115,116, + 97,114,116,115,119,105,116,104,218,27,95,67,65,83,69,95, + 73,78,83,69,78,83,73,84,73,86,69,95,80,76,65,84, + 70,79,82,77,83,41,1,114,6,0,0,0,114,4,0,0, + 0,114,4,0,0,0,114,5,0,0,0,218,16,95,109,97, + 107,101,95,114,101,108,97,120,95,99,97,115,101,28,0,0, + 0,115,8,0,0,0,0,1,18,1,15,4,12,3,114,11, + 0,0,0,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,131,1,0,100,1,0,64,106,1,0,100,2,0, + 100,3,0,131,2,0,83,41,4,122,42,67,111,110,118,101, + 114,116,32,97,32,51,50,45,98,105,116,32,105,110,116,101, + 103,101,114,32,116,111,32,108,105,116,116,108,101,45,101,110, + 100,105,97,110,46,108,3,0,0,0,255,127,255,127,3,0, + 233,4,0,0,0,218,6,108,105,116,116,108,101,41,2,218, + 3,105,110,116,218,8,116,111,95,98,121,116,101,115,41,1, + 218,1,120,114,4,0,0,0,114,4,0,0,0,114,5,0, + 0,0,218,7,95,119,95,108,111,110,103,40,0,0,0,115, + 2,0,0,0,0,2,114,17,0,0,0,99,1,0,0,0, + 0,0,0,0,1,0,0,0,3,0,0,0,67,0,0,0, + 115,16,0,0,0,116,0,0,106,1,0,124,0,0,100,1, + 0,131,2,0,83,41,2,122,47,67,111,110,118,101,114,116, + 32,52,32,98,121,116,101,115,32,105,110,32,108,105,116,116, + 108,101,45,101,110,100,105,97,110,32,116,111,32,97,110,32, + 105,110,116,101,103,101,114,46,114,13,0,0,0,41,2,114, + 14,0,0,0,218,10,102,114,111,109,95,98,121,116,101,115, + 41,1,90,9,105,110,116,95,98,121,116,101,115,114,4,0, + 0,0,114,4,0,0,0,114,5,0,0,0,218,7,95,114, + 95,108,111,110,103,45,0,0,0,115,2,0,0,0,0,2, + 114,19,0,0,0,99,0,0,0,0,0,0,0,0,1,0, + 0,0,3,0,0,0,71,0,0,0,115,26,0,0,0,116, + 0,0,106,1,0,100,1,0,100,2,0,132,0,0,124,0, + 0,68,131,1,0,131,1,0,83,41,3,122,31,82,101,112, + 108,97,99,101,109,101,110,116,32,102,111,114,32,111,115,46, + 112,97,116,104,46,106,111,105,110,40,41,46,99,1,0,0, + 0,0,0,0,0,2,0,0,0,4,0,0,0,83,0,0, + 0,115,37,0,0,0,103,0,0,124,0,0,93,27,0,125, + 1,0,124,1,0,114,6,0,124,1,0,106,0,0,116,1, + 0,131,1,0,145,2,0,113,6,0,83,114,4,0,0,0, + 41,2,218,6,114,115,116,114,105,112,218,15,112,97,116,104, + 95,115,101,112,97,114,97,116,111,114,115,41,2,218,2,46, + 48,218,4,112,97,114,116,114,4,0,0,0,114,4,0,0, + 0,114,5,0,0,0,250,10,60,108,105,115,116,99,111,109, + 112,62,52,0,0,0,115,2,0,0,0,9,1,122,30,95, + 112,97,116,104,95,106,111,105,110,46,60,108,111,99,97,108, + 115,62,46,60,108,105,115,116,99,111,109,112,62,41,2,218, + 8,112,97,116,104,95,115,101,112,218,4,106,111,105,110,41, + 1,218,10,112,97,116,104,95,112,97,114,116,115,114,4,0, + 0,0,114,4,0,0,0,114,5,0,0,0,218,10,95,112, + 97,116,104,95,106,111,105,110,50,0,0,0,115,4,0,0, + 0,0,2,15,1,114,28,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, + 134,0,0,0,116,0,0,116,1,0,131,1,0,100,1,0, + 107,2,0,114,52,0,124,0,0,106,2,0,116,3,0,131, + 1,0,92,3,0,125,1,0,125,2,0,125,3,0,124,1, + 0,124,3,0,102,2,0,83,120,69,0,116,4,0,124,0, + 0,131,1,0,68,93,55,0,125,4,0,124,4,0,116,1, + 0,107,6,0,114,65,0,124,0,0,106,5,0,124,4,0, + 100,2,0,100,1,0,131,1,1,92,2,0,125,1,0,125, + 3,0,124,1,0,124,3,0,102,2,0,83,113,65,0,87, + 100,3,0,124,0,0,102,2,0,83,41,4,122,32,82,101, + 112,108,97,99,101,109,101,110,116,32,102,111,114,32,111,115, + 46,112,97,116,104,46,115,112,108,105,116,40,41,46,233,1, + 0,0,0,90,8,109,97,120,115,112,108,105,116,218,0,41, + 6,218,3,108,101,110,114,21,0,0,0,218,10,114,112,97, + 114,116,105,116,105,111,110,114,25,0,0,0,218,8,114,101, + 118,101,114,115,101,100,218,6,114,115,112,108,105,116,41,5, + 218,4,112,97,116,104,90,5,102,114,111,110,116,218,1,95, + 218,4,116,97,105,108,114,16,0,0,0,114,4,0,0,0, + 114,4,0,0,0,114,5,0,0,0,218,11,95,112,97,116, + 104,95,115,112,108,105,116,56,0,0,0,115,16,0,0,0, + 0,2,18,1,24,1,10,1,19,1,12,1,27,1,14,1, + 114,38,0,0,0,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,116, + 0,0,106,1,0,124,0,0,131,1,0,83,41,1,122,126, + 83,116,97,116,32,116,104,101,32,112,97,116,104,46,10,10, + 32,32,32,32,77,97,100,101,32,97,32,115,101,112,97,114, + 97,116,101,32,102,117,110,99,116,105,111,110,32,116,111,32, + 109,97,107,101,32,105,116,32,101,97,115,105,101,114,32,116, + 111,32,111,118,101,114,114,105,100,101,32,105,110,32,101,120, + 112,101,114,105,109,101,110,116,115,10,32,32,32,32,40,101, + 46,103,46,32,99,97,99,104,101,32,115,116,97,116,32,114, + 101,115,117,108,116,115,41,46,10,10,32,32,32,32,41,2, + 114,3,0,0,0,90,4,115,116,97,116,41,1,114,35,0, + 0,0,114,4,0,0,0,114,4,0,0,0,114,5,0,0, + 0,218,10,95,112,97,116,104,95,115,116,97,116,68,0,0, + 0,115,2,0,0,0,0,7,114,39,0,0,0,99,2,0, + 0,0,0,0,0,0,3,0,0,0,11,0,0,0,67,0, + 0,0,115,58,0,0,0,121,16,0,116,0,0,124,0,0, + 131,1,0,125,2,0,87,110,22,0,4,116,1,0,107,10, + 0,114,40,0,1,1,1,100,1,0,83,89,110,1,0,88, + 124,2,0,106,2,0,100,2,0,64,124,1,0,107,2,0, + 83,41,3,122,49,84,101,115,116,32,119,104,101,116,104,101, + 114,32,116,104,101,32,112,97,116,104,32,105,115,32,116,104, + 101,32,115,112,101,99,105,102,105,101,100,32,109,111,100,101, + 32,116,121,112,101,46,70,105,0,240,0,0,41,3,114,39, + 0,0,0,218,7,79,83,69,114,114,111,114,218,7,115,116, + 95,109,111,100,101,41,3,114,35,0,0,0,218,4,109,111, + 100,101,90,9,115,116,97,116,95,105,110,102,111,114,4,0, + 0,0,114,4,0,0,0,114,5,0,0,0,218,18,95,112, + 97,116,104,95,105,115,95,109,111,100,101,95,116,121,112,101, + 78,0,0,0,115,10,0,0,0,0,2,3,1,16,1,13, + 1,9,1,114,43,0,0,0,99,1,0,0,0,0,0,0, + 0,1,0,0,0,3,0,0,0,67,0,0,0,115,13,0, + 0,0,116,0,0,124,0,0,100,1,0,131,2,0,83,41, + 2,122,31,82,101,112,108,97,99,101,109,101,110,116,32,102, + 111,114,32,111,115,46,112,97,116,104,46,105,115,102,105,108, + 101,46,105,0,128,0,0,41,1,114,43,0,0,0,41,1, + 114,35,0,0,0,114,4,0,0,0,114,4,0,0,0,114, + 5,0,0,0,218,12,95,112,97,116,104,95,105,115,102,105, + 108,101,87,0,0,0,115,2,0,0,0,0,2,114,44,0, + 0,0,99,1,0,0,0,0,0,0,0,1,0,0,0,3, + 0,0,0,67,0,0,0,115,31,0,0,0,124,0,0,115, + 18,0,116,0,0,106,1,0,131,0,0,125,0,0,116,2, + 0,124,0,0,100,1,0,131,2,0,83,41,2,122,30,82, + 101,112,108,97,99,101,109,101,110,116,32,102,111,114,32,111, + 115,46,112,97,116,104,46,105,115,100,105,114,46,105,0,64, + 0,0,41,3,114,3,0,0,0,218,6,103,101,116,99,119, + 100,114,43,0,0,0,41,1,114,35,0,0,0,114,4,0, + 0,0,114,4,0,0,0,114,5,0,0,0,218,11,95,112, + 97,116,104,95,105,115,100,105,114,92,0,0,0,115,6,0, + 0,0,0,2,6,1,12,1,114,46,0,0,0,105,182,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,193,0,0,0,100,1,0,106, + 0,0,124,0,0,116,1,0,124,0,0,131,1,0,131,2, + 0,125,3,0,116,2,0,106,3,0,124,3,0,116,2,0, + 106,4,0,116,2,0,106,5,0,66,116,2,0,106,6,0, + 66,124,2,0,100,2,0,64,131,3,0,125,4,0,121,61, + 0,116,7,0,106,8,0,124,4,0,100,3,0,131,2,0, + 143,20,0,125,5,0,124,5,0,106,9,0,124,1,0,131, + 1,0,1,87,100,4,0,81,82,88,116,2,0,106,10,0, + 124,3,0,124,0,0,131,2,0,1,87,110,59,0,4,116, + 11,0,107,10,0,114,188,0,1,1,1,121,17,0,116,2, + 0,106,12,0,124,3,0,131,1,0,1,87,110,18,0,4, + 116,11,0,107,10,0,114,180,0,1,1,1,89,110,1,0, + 88,130,0,0,89,110,1,0,88,100,4,0,83,41,5,122, + 162,66,101,115,116,45,101,102,102,111,114,116,32,102,117,110, + 99,116,105,111,110,32,116,111,32,119,114,105,116,101,32,100, + 97,116,97,32,116,111,32,97,32,112,97,116,104,32,97,116, + 111,109,105,99,97,108,108,121,46,10,32,32,32,32,66,101, + 32,112,114,101,112,97,114,101,100,32,116,111,32,104,97,110, + 100,108,101,32,97,32,70,105,108,101,69,120,105,115,116,115, + 69,114,114,111,114,32,105,102,32,99,111,110,99,117,114,114, + 101,110,116,32,119,114,105,116,105,110,103,32,111,102,32,116, + 104,101,10,32,32,32,32,116,101,109,112,111,114,97,114,121, + 32,102,105,108,101,32,105,115,32,97,116,116,101,109,112,116, + 101,100,46,122,5,123,125,46,123,125,105,182,1,0,0,90, + 2,119,98,78,41,13,218,6,102,111,114,109,97,116,218,2, + 105,100,114,3,0,0,0,90,4,111,112,101,110,90,6,79, + 95,69,88,67,76,90,7,79,95,67,82,69,65,84,90,8, + 79,95,87,82,79,78,76,89,218,3,95,105,111,218,6,70, + 105,108,101,73,79,218,5,119,114,105,116,101,218,7,114,101, + 112,108,97,99,101,114,40,0,0,0,90,6,117,110,108,105, + 110,107,41,6,114,35,0,0,0,218,4,100,97,116,97,114, + 42,0,0,0,90,8,112,97,116,104,95,116,109,112,90,2, + 102,100,218,4,102,105,108,101,114,4,0,0,0,114,4,0, + 0,0,114,5,0,0,0,218,13,95,119,114,105,116,101,95, + 97,116,111,109,105,99,99,0,0,0,115,26,0,0,0,0, + 5,24,1,9,1,33,1,3,3,21,1,20,1,20,1,13, + 1,3,1,17,1,13,1,5,1,114,55,0,0,0,105,22, + 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,4,111,112,116,45,122,3,46,112,121,122,4,46,112, + 121,99,78,218,12,111,112,116,105,109,105,122,97,116,105,111, + 110,99,2,0,0,0,1,0,0,0,11,0,0,0,6,0, + 0,0,67,0,0,0,115,87,1,0,0,124,1,0,100,1, + 0,107,9,0,114,76,0,116,0,0,106,1,0,100,2,0, + 116,2,0,131,2,0,1,124,2,0,100,1,0,107,9,0, + 114,58,0,100,3,0,125,3,0,116,3,0,124,3,0,131, + 1,0,130,1,0,124,1,0,114,70,0,100,4,0,110,3, + 0,100,5,0,125,2,0,116,4,0,124,0,0,131,1,0, + 92,2,0,125,4,0,125,5,0,124,5,0,106,5,0,100, + 6,0,131,1,0,92,3,0,125,6,0,125,7,0,125,8, + 0,116,6,0,106,7,0,106,8,0,125,9,0,124,9,0, + 100,1,0,107,8,0,114,154,0,116,9,0,100,7,0,131, + 1,0,130,1,0,100,4,0,106,10,0,124,6,0,114,172, + 0,124,6,0,110,3,0,124,8,0,124,7,0,124,9,0, + 103,3,0,131,1,0,125,10,0,124,2,0,100,1,0,107, + 8,0,114,241,0,116,6,0,106,11,0,106,12,0,100,8, + 0,107,2,0,114,229,0,100,4,0,125,2,0,110,12,0, + 116,6,0,106,11,0,106,12,0,125,2,0,116,13,0,124, + 2,0,131,1,0,125,2,0,124,2,0,100,4,0,107,3, + 0,114,63,1,124,2,0,106,14,0,131,0,0,115,42,1, + 116,15,0,100,9,0,106,16,0,124,2,0,131,1,0,131, + 1,0,130,1,0,100,10,0,106,16,0,124,10,0,116,17, + 0,124,2,0,131,3,0,125,10,0,116,18,0,124,4,0, + 116,19,0,124,10,0,116,20,0,100,8,0,25,23,131,3, + 0,83,41,11,97,254,2,0,0,71,105,118,101,110,32,116, + 104,101,32,112,97,116,104,32,116,111,32,97,32,46,112,121, + 32,102,105,108,101,44,32,114,101,116,117,114,110,32,116,104, + 101,32,112,97,116,104,32,116,111,32,105,116,115,32,46,112, + 121,99,32,102,105,108,101,46,10,10,32,32,32,32,84,104, + 101,32,46,112,121,32,102,105,108,101,32,100,111,101,115,32, + 110,111,116,32,110,101,101,100,32,116,111,32,101,120,105,115, + 116,59,32,116,104,105,115,32,115,105,109,112,108,121,32,114, + 101,116,117,114,110,115,32,116,104,101,32,112,97,116,104,32, + 116,111,32,116,104,101,10,32,32,32,32,46,112,121,99,32, + 102,105,108,101,32,99,97,108,99,117,108,97,116,101,100,32, + 97,115,32,105,102,32,116,104,101,32,46,112,121,32,102,105, + 108,101,32,119,101,114,101,32,105,109,112,111,114,116,101,100, + 46,10,10,32,32,32,32,84,104,101,32,39,111,112,116,105, + 109,105,122,97,116,105,111,110,39,32,112,97,114,97,109,101, + 116,101,114,32,99,111,110,116,114,111,108,115,32,116,104,101, + 32,112,114,101,115,117,109,101,100,32,111,112,116,105,109,105, + 122,97,116,105,111,110,32,108,101,118,101,108,32,111,102,10, + 32,32,32,32,116,104,101,32,98,121,116,101,99,111,100,101, + 32,102,105,108,101,46,32,73,102,32,39,111,112,116,105,109, + 105,122,97,116,105,111,110,39,32,105,115,32,110,111,116,32, + 78,111,110,101,44,32,116,104,101,32,115,116,114,105,110,103, + 32,114,101,112,114,101,115,101,110,116,97,116,105,111,110,10, + 32,32,32,32,111,102,32,116,104,101,32,97,114,103,117,109, + 101,110,116,32,105,115,32,116,97,107,101,110,32,97,110,100, + 32,118,101,114,105,102,105,101,100,32,116,111,32,98,101,32, + 97,108,112,104,97,110,117,109,101,114,105,99,32,40,101,108, + 115,101,32,86,97,108,117,101,69,114,114,111,114,10,32,32, + 32,32,105,115,32,114,97,105,115,101,100,41,46,10,10,32, + 32,32,32,84,104,101,32,100,101,98,117,103,95,111,118,101, + 114,114,105,100,101,32,112,97,114,97,109,101,116,101,114,32, + 105,115,32,100,101,112,114,101,99,97,116,101,100,46,32,73, + 102,32,100,101,98,117,103,95,111,118,101,114,114,105,100,101, + 32,105,115,32,110,111,116,32,78,111,110,101,44,10,32,32, + 32,32,97,32,84,114,117,101,32,118,97,108,117,101,32,105, + 115,32,116,104,101,32,115,97,109,101,32,97,115,32,115,101, + 116,116,105,110,103,32,39,111,112,116,105,109,105,122,97,116, + 105,111,110,39,32,116,111,32,116,104,101,32,101,109,112,116, + 121,32,115,116,114,105,110,103,10,32,32,32,32,119,104,105, + 108,101,32,97,32,70,97,108,115,101,32,118,97,108,117,101, + 32,105,115,32,101,113,117,105,118,97,108,101,110,116,32,116, + 111,32,115,101,116,116,105,110,103,32,39,111,112,116,105,109, + 105,122,97,116,105,111,110,39,32,116,111,32,39,49,39,46, + 10,10,32,32,32,32,73,102,32,115,121,115,46,105,109,112, + 108,101,109,101,110,116,97,116,105,111,110,46,99,97,99,104, + 101,95,116,97,103,32,105,115,32,78,111,110,101,32,116,104, + 101,110,32,78,111,116,73,109,112,108,101,109,101,110,116,101, + 100,69,114,114,111,114,32,105,115,32,114,97,105,115,101,100, + 46,10,10,32,32,32,32,78,122,70,116,104,101,32,100,101, + 98,117,103,95,111,118,101,114,114,105,100,101,32,112,97,114, + 97,109,101,116,101,114,32,105,115,32,100,101,112,114,101,99, + 97,116,101,100,59,32,117,115,101,32,39,111,112,116,105,109, + 105,122,97,116,105,111,110,39,32,105,110,115,116,101,97,100, + 122,50,100,101,98,117,103,95,111,118,101,114,114,105,100,101, + 32,111,114,32,111,112,116,105,109,105,122,97,116,105,111,110, + 32,109,117,115,116,32,98,101,32,115,101,116,32,116,111,32, + 78,111,110,101,114,30,0,0,0,114,29,0,0,0,218,1, + 46,122,36,115,121,115,46,105,109,112,108,101,109,101,110,116, + 97,116,105,111,110,46,99,97,99,104,101,95,116,97,103,32, + 105,115,32,78,111,110,101,233,0,0,0,0,122,24,123,33, + 114,125,32,105,115,32,110,111,116,32,97,108,112,104,97,110, + 117,109,101,114,105,99,122,7,123,125,46,123,125,123,125,41, + 21,218,9,95,119,97,114,110,105,110,103,115,218,4,119,97, + 114,110,218,18,68,101,112,114,101,99,97,116,105,111,110,87, + 97,114,110,105,110,103,218,9,84,121,112,101,69,114,114,111, + 114,114,38,0,0,0,114,32,0,0,0,114,7,0,0,0, + 218,14,105,109,112,108,101,109,101,110,116,97,116,105,111,110, + 218,9,99,97,99,104,101,95,116,97,103,218,19,78,111,116, + 73,109,112,108,101,109,101,110,116,101,100,69,114,114,111,114, + 114,26,0,0,0,218,5,102,108,97,103,115,218,8,111,112, + 116,105,109,105,122,101,218,3,115,116,114,218,7,105,115,97, + 108,110,117,109,218,10,86,97,108,117,101,69,114,114,111,114, + 114,47,0,0,0,218,4,95,79,80,84,114,28,0,0,0, + 218,8,95,80,89,67,65,67,72,69,218,17,66,89,84,69, + 67,79,68,69,95,83,85,70,70,73,88,69,83,41,11,114, + 35,0,0,0,90,14,100,101,98,117,103,95,111,118,101,114, + 114,105,100,101,114,57,0,0,0,218,7,109,101,115,115,97, + 103,101,218,4,104,101,97,100,114,37,0,0,0,90,4,98, + 97,115,101,218,3,115,101,112,218,4,114,101,115,116,90,3, + 116,97,103,90,15,97,108,109,111,115,116,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,99,97,99,104,101,95,102,114,111,109,95, + 115,111,117,114,99,101,243,0,0,0,115,46,0,0,0,0, + 18,12,1,9,1,7,1,12,1,6,1,12,1,18,1,18, + 1,24,1,12,1,12,1,12,1,36,1,12,1,18,1,9, + 2,12,1,12,1,12,1,12,1,21,1,21,1,114,79,0, + 0,0,99,1,0,0,0,0,0,0,0,8,0,0,0,5, + 0,0,0,67,0,0,0,115,62,1,0,0,116,0,0,106, + 1,0,106,2,0,100,1,0,107,8,0,114,30,0,116,3, + 0,100,2,0,131,1,0,130,1,0,116,4,0,124,0,0, + 131,1,0,92,2,0,125,1,0,125,2,0,116,4,0,124, + 1,0,131,1,0,92,2,0,125,1,0,125,3,0,124,3, + 0,116,5,0,107,3,0,114,102,0,116,6,0,100,3,0, + 106,7,0,116,5,0,124,0,0,131,2,0,131,1,0,130, + 1,0,124,2,0,106,8,0,100,4,0,131,1,0,125,4, + 0,124,4,0,100,11,0,107,7,0,114,153,0,116,6,0, + 100,7,0,106,7,0,124,2,0,131,1,0,131,1,0,130, + 1,0,110,125,0,124,4,0,100,6,0,107,2,0,114,22, + 1,124,2,0,106,9,0,100,4,0,100,5,0,131,2,0, + 100,12,0,25,125,5,0,124,5,0,106,10,0,116,11,0, + 131,1,0,115,223,0,116,6,0,100,8,0,106,7,0,116, + 11,0,131,1,0,131,1,0,130,1,0,124,5,0,116,12, + 0,116,11,0,131,1,0,100,1,0,133,2,0,25,125,6, + 0,124,6,0,106,13,0,131,0,0,115,22,1,116,6,0, + 100,9,0,106,7,0,124,5,0,131,1,0,131,1,0,130, + 1,0,124,2,0,106,14,0,100,4,0,131,1,0,100,10, + 0,25,125,7,0,116,15,0,124,1,0,124,7,0,116,16, + 0,100,10,0,25,23,131,2,0,83,41,13,97,110,1,0, + 0,71,105,118,101,110,32,116,104,101,32,112,97,116,104,32, + 116,111,32,97,32,46,112,121,99,46,32,102,105,108,101,44, + 32,114,101,116,117,114,110,32,116,104,101,32,112,97,116,104, + 32,116,111,32,105,116,115,32,46,112,121,32,102,105,108,101, + 46,10,10,32,32,32,32,84,104,101,32,46,112,121,99,32, + 102,105,108,101,32,100,111,101,115,32,110,111,116,32,110,101, + 101,100,32,116,111,32,101,120,105,115,116,59,32,116,104,105, + 115,32,115,105,109,112,108,121,32,114,101,116,117,114,110,115, + 32,116,104,101,32,112,97,116,104,32,116,111,10,32,32,32, + 32,116,104,101,32,46,112,121,32,102,105,108,101,32,99,97, + 108,99,117,108,97,116,101,100,32,116,111,32,99,111,114,114, + 101,115,112,111,110,100,32,116,111,32,116,104,101,32,46,112, + 121,99,32,102,105,108,101,46,32,32,73,102,32,112,97,116, + 104,32,100,111,101,115,10,32,32,32,32,110,111,116,32,99, + 111,110,102,111,114,109,32,116,111,32,80,69,80,32,51,49, + 52,55,47,52,56,56,32,102,111,114,109,97,116,44,32,86, + 97,108,117,101,69,114,114,111,114,32,119,105,108,108,32,98, + 101,32,114,97,105,115,101,100,46,32,73,102,10,32,32,32, + 32,115,121,115,46,105,109,112,108,101,109,101,110,116,97,116, + 105,111,110,46,99,97,99,104,101,95,116,97,103,32,105,115, + 32,78,111,110,101,32,116,104,101,110,32,78,111,116,73,109, + 112,108,101,109,101,110,116,101,100,69,114,114,111,114,32,105, + 115,32,114,97,105,115,101,100,46,10,10,32,32,32,32,78, + 122,36,115,121,115,46,105,109,112,108,101,109,101,110,116,97, + 116,105,111,110,46,99,97,99,104,101,95,116,97,103,32,105, + 115,32,78,111,110,101,122,37,123,125,32,110,111,116,32,98, + 111,116,116,111,109,45,108,101,118,101,108,32,100,105,114,101, + 99,116,111,114,121,32,105,110,32,123,33,114,125,114,58,0, + 0,0,114,56,0,0,0,233,3,0,0,0,122,33,101,120, + 112,101,99,116,101,100,32,111,110,108,121,32,50,32,111,114, + 32,51,32,100,111,116,115,32,105,110,32,123,33,114,125,122, + 57,111,112,116,105,109,105,122,97,116,105,111,110,32,112,111, + 114,116,105,111,110,32,111,102,32,102,105,108,101,110,97,109, + 101,32,100,111,101,115,32,110,111,116,32,115,116,97,114,116, + 32,119,105,116,104,32,123,33,114,125,122,52,111,112,116,105, + 109,105,122,97,116,105,111,110,32,108,101,118,101,108,32,123, + 33,114,125,32,105,115,32,110,111,116,32,97,110,32,97,108, + 112,104,97,110,117,109,101,114,105,99,32,118,97,108,117,101, + 114,59,0,0,0,62,2,0,0,0,114,56,0,0,0,114, + 80,0,0,0,233,254,255,255,255,41,17,114,7,0,0,0, + 114,64,0,0,0,114,65,0,0,0,114,66,0,0,0,114, + 38,0,0,0,114,73,0,0,0,114,71,0,0,0,114,47, + 0,0,0,218,5,99,111,117,110,116,114,34,0,0,0,114, + 9,0,0,0,114,72,0,0,0,114,31,0,0,0,114,70, + 0,0,0,218,9,112,97,114,116,105,116,105,111,110,114,28, + 0,0,0,218,15,83,79,85,82,67,69,95,83,85,70,70, + 73,88,69,83,41,8,114,35,0,0,0,114,76,0,0,0, + 90,16,112,121,99,97,99,104,101,95,102,105,108,101,110,97, + 109,101,90,7,112,121,99,97,99,104,101,90,9,100,111,116, + 95,99,111,117,110,116,114,57,0,0,0,90,9,111,112,116, + 95,108,101,118,101,108,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,31,1,0,0,115,44,0,0,0, + 0,9,18,1,12,1,18,1,18,1,12,1,9,1,15,1, + 15,1,12,1,9,1,15,1,12,1,22,1,15,1,9,1, + 12,1,22,1,12,1,9,1,12,1,19,1,114,85,0,0, + 0,99,1,0,0,0,0,0,0,0,5,0,0,0,12,0, + 0,0,67,0,0,0,115,164,0,0,0,116,0,0,124,0, + 0,131,1,0,100,1,0,107,2,0,114,22,0,100,2,0, + 83,124,0,0,106,1,0,100,3,0,131,1,0,92,3,0, + 125,1,0,125,2,0,125,3,0,124,1,0,12,115,81,0, + 124,3,0,106,2,0,131,0,0,100,7,0,100,8,0,133, + 2,0,25,100,6,0,107,3,0,114,85,0,124,0,0,83, + 121,16,0,116,3,0,124,0,0,131,1,0,125,4,0,87, + 110,40,0,4,116,4,0,116,5,0,102,2,0,107,10,0, + 114,143,0,1,1,1,124,0,0,100,2,0,100,9,0,133, + 2,0,25,125,4,0,89,110,1,0,88,116,6,0,124,4, + 0,131,1,0,114,160,0,124,4,0,83,124,0,0,83,41, + 10,122,188,67,111,110,118,101,114,116,32,97,32,98,121,116, + 101,99,111,100,101,32,102,105,108,101,32,112,97,116,104,32, + 116,111,32,97,32,115,111,117,114,99,101,32,112,97,116,104, + 32,40,105,102,32,112,111,115,115,105,98,108,101,41,46,10, + 10,32,32,32,32,84,104,105,115,32,102,117,110,99,116,105, + 111,110,32,101,120,105,115,116,115,32,112,117,114,101,108,121, + 32,102,111,114,32,98,97,99,107,119,97,114,100,115,45,99, + 111,109,112,97,116,105,98,105,108,105,116,121,32,102,111,114, + 10,32,32,32,32,80,121,73,109,112,111,114,116,95,69,120, + 101,99,67,111,100,101,77,111,100,117,108,101,87,105,116,104, + 70,105,108,101,110,97,109,101,115,40,41,32,105,110,32,116, + 104,101,32,67,32,65,80,73,46,10,10,32,32,32,32,114, + 59,0,0,0,78,114,58,0,0,0,114,80,0,0,0,114, + 29,0,0,0,90,2,112,121,233,253,255,255,255,233,255,255, + 255,255,114,87,0,0,0,41,7,114,31,0,0,0,114,32, + 0,0,0,218,5,108,111,119,101,114,114,85,0,0,0,114, + 66,0,0,0,114,71,0,0,0,114,44,0,0,0,41,5, + 218,13,98,121,116,101,99,111,100,101,95,112,97,116,104,114, + 78,0,0,0,114,36,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,64,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,91, + 0,0,0,99,1,0,0,0,0,0,0,0,1,0,0,0, + 11,0,0,0,67,0,0,0,115,92,0,0,0,124,0,0, + 106,0,0,116,1,0,116,2,0,131,1,0,131,1,0,114, + 59,0,121,14,0,116,3,0,124,0,0,131,1,0,83,87, + 113,88,0,4,116,4,0,107,10,0,114,55,0,1,1,1, + 89,113,88,0,88,110,29,0,124,0,0,106,0,0,116,1, + 0,116,5,0,131,1,0,131,1,0,114,84,0,124,0,0, + 83,100,0,0,83,100,0,0,83,41,1,78,41,6,218,8, + 101,110,100,115,119,105,116,104,218,5,116,117,112,108,101,114, + 84,0,0,0,114,79,0,0,0,114,66,0,0,0,114,74, + 0,0,0,41,1,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,11, + 95,103,101,116,95,99,97,99,104,101,100,83,1,0,0,115, + 16,0,0,0,0,1,21,1,3,1,14,1,13,1,8,1, + 21,1,4,2,114,95,0,0,0,99,1,0,0,0,0,0, + 0,0,2,0,0,0,11,0,0,0,67,0,0,0,115,60, + 0,0,0,121,19,0,116,0,0,124,0,0,131,1,0,106, + 1,0,125,1,0,87,110,24,0,4,116,2,0,107,10,0, + 114,45,0,1,1,1,100,1,0,125,1,0,89,110,1,0, + 88,124,1,0,100,2,0,79,125,1,0,124,1,0,83,41, + 3,122,51,67,97,108,99,117,108,97,116,101,32,116,104,101, + 32,109,111,100,101,32,112,101,114,109,105,115,115,105,111,110, + 115,32,102,111,114,32,97,32,98,121,116,101,99,111,100,101, + 32,102,105,108,101,46,105,182,1,0,0,233,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,95,1,0,0,115,12,0,0, + 0,0,2,3,1,19,1,13,1,11,3,10,1,114,97,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,0,0,0,4, + 0,0,0,71,0,0,0,115,75,0,0,0,116,0,0,106, + 1,0,106,2,0,124,1,0,107,5,0,114,71,0,124,0, + 0,106,3,0,100,6,0,131,1,0,115,43,0,100,3,0, + 124,0,0,23,125,0,0,116,4,0,124,0,0,106,5,0, + 124,2,0,140,0,0,100,4,0,116,0,0,106,6,0,131, + 1,1,1,100,5,0,83,41,7,122,61,80,114,105,110,116, + 32,116,104,101,32,109,101,115,115,97,103,101,32,116,111,32, + 115,116,100,101,114,114,32,105,102,32,45,118,47,80,89,84, + 72,79,78,86,69,82,66,79,83,69,32,105,115,32,116,117, + 114,110,101,100,32,111,110,46,250,1,35,250,7,105,109,112, + 111,114,116,32,122,2,35,32,114,54,0,0,0,78,41,2, + 114,99,0,0,0,114,100,0,0,0,41,7,114,7,0,0, + 0,114,67,0,0,0,218,7,118,101,114,98,111,115,101,114, + 9,0,0,0,218,5,112,114,105,110,116,114,47,0,0,0, + 218,6,115,116,100,101,114,114,41,3,114,75,0,0,0,114, + 98,0,0,0,218,4,97,114,103,115,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,107,1,0,0,115, + 8,0,0,0,0,2,18,1,15,1,10,1,114,105,0,0, + 0,99,1,0,0,0,0,0,0,0,3,0,0,0,11,0, + 0,0,3,0,0,0,115,84,0,0,0,100,1,0,135,0, + 0,102,1,0,100,2,0,100,3,0,134,1,0,125,1,0, + 121,13,0,116,0,0,106,1,0,125,2,0,87,110,30,0, + 4,116,2,0,107,10,0,114,66,0,1,1,1,100,4,0, + 100,5,0,132,0,0,125,2,0,89,110,1,0,88,124,2, + 0,124,1,0,136,0,0,131,2,0,1,124,1,0,83,41, + 6,122,252,68,101,99,111,114,97,116,111,114,32,116,111,32, + 118,101,114,105,102,121,32,116,104,97,116,32,116,104,101,32, + 109,111,100,117,108,101,32,98,101,105,110,103,32,114,101,113, + 117,101,115,116,101,100,32,109,97,116,99,104,101,115,32,116, + 104,101,32,111,110,101,32,116,104,101,10,32,32,32,32,108, + 111,97,100,101,114,32,99,97,110,32,104,97,110,100,108,101, + 46,10,10,32,32,32,32,84,104,101,32,102,105,114,115,116, + 32,97,114,103,117,109,101,110,116,32,40,115,101,108,102,41, + 32,109,117,115,116,32,100,101,102,105,110,101,32,95,110,97, + 109,101,32,119,104,105,99,104,32,116,104,101,32,115,101,99, + 111,110,100,32,97,114,103,117,109,101,110,116,32,105,115,10, + 32,32,32,32,99,111,109,112,97,114,101,100,32,97,103,97, + 105,110,115,116,46,32,73,102,32,116,104,101,32,99,111,109, + 112,97,114,105,115,111,110,32,102,97,105,108,115,32,116,104, + 101,110,32,73,109,112,111,114,116,69,114,114,111,114,32,105, + 115,32,114,97,105,115,101,100,46,10,10,32,32,32,32,78, + 99,2,0,0,0,0,0,0,0,4,0,0,0,5,0,0, + 0,31,0,0,0,115,89,0,0,0,124,1,0,100,0,0, + 107,8,0,114,24,0,124,0,0,106,0,0,125,1,0,110, + 46,0,124,0,0,106,0,0,124,1,0,107,3,0,114,70, + 0,116,1,0,100,1,0,124,0,0,106,0,0,124,1,0, + 102,2,0,22,100,2,0,124,1,0,131,1,1,130,1,0, + 136,0,0,124,0,0,124,1,0,124,2,0,124,3,0,142, + 2,0,83,41,3,78,122,30,108,111,97,100,101,114,32,102, + 111,114,32,37,115,32,99,97,110,110,111,116,32,104,97,110, + 100,108,101,32,37,115,218,4,110,97,109,101,41,2,114,106, + 0,0,0,218,11,73,109,112,111,114,116,69,114,114,111,114, + 41,4,218,4,115,101,108,102,114,106,0,0,0,114,104,0, + 0,0,90,6,107,119,97,114,103,115,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,123,1,0,0,115,12,0,0,0,0,1,12,1, + 12,1,15,1,6,1,25,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,99,2,0,0,0,0,0,0,0,3,0,0,0,7, + 0,0,0,83,0,0,0,115,92,0,0,0,120,66,0,100, + 1,0,100,2,0,100,3,0,100,4,0,103,4,0,68,93, + 46,0,125,2,0,116,0,0,124,1,0,124,2,0,131,2, + 0,114,19,0,116,1,0,124,0,0,124,2,0,116,2,0, + 124,1,0,124,2,0,131,2,0,131,3,0,1,113,19,0, + 87,124,0,0,106,3,0,106,4,0,124,1,0,106,3,0, + 131,1,0,1,100,0,0,83,41,5,78,218,10,95,95,109, + 111,100,117,108,101,95,95,218,8,95,95,110,97,109,101,95, + 95,218,12,95,95,113,117,97,108,110,97,109,101,95,95,218, + 7,95,95,100,111,99,95,95,41,5,218,7,104,97,115,97, + 116,116,114,218,7,115,101,116,97,116,116,114,218,7,103,101, + 116,97,116,116,114,218,8,95,95,100,105,99,116,95,95,218, + 6,117,112,100,97,116,101,41,3,90,3,110,101,119,90,3, + 111,108,100,114,52,0,0,0,114,4,0,0,0,114,4,0, + 0,0,114,5,0,0,0,218,5,95,119,114,97,112,134,1, + 0,0,115,8,0,0,0,0,1,25,1,15,1,29,1,122, + 26,95,99,104,101,99,107,95,110,97,109,101,46,60,108,111, + 99,97,108,115,62,46,95,119,114,97,112,41,3,218,10,95, + 98,111,111,116,115,116,114,97,112,114,120,0,0,0,218,9, + 78,97,109,101,69,114,114,111,114,41,3,114,109,0,0,0, + 114,110,0,0,0,114,120,0,0,0,114,4,0,0,0,41, + 1,114,109,0,0,0,114,5,0,0,0,218,11,95,99,104, + 101,99,107,95,110,97,109,101,115,1,0,0,115,14,0,0, + 0,0,8,21,7,3,1,13,1,13,2,17,5,13,1,114, + 123,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,0,124,1,0,131,1,0,92,2,0,125,2,0, + 125,3,0,124,2,0,100,1,0,107,8,0,114,80,0,116, + 1,0,124,3,0,131,1,0,114,80,0,100,2,0,125,4, + 0,116,2,0,106,3,0,124,4,0,106,4,0,124,3,0, + 100,3,0,25,131,1,0,116,5,0,131,2,0,1,124,2, + 0,83,41,4,122,155,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,32,98,121,32,100,101,108,101,103,97,116,105,110, + 103,32,116,111,10,32,32,32,32,115,101,108,102,46,102,105, + 110,100,95,108,111,97,100,101,114,40,41,46,10,10,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,32,105,110,32,102, + 97,118,111,114,32,111,102,32,102,105,110,100,101,114,46,102, + 105,110,100,95,115,112,101,99,40,41,46,10,10,32,32,32, + 32,78,122,44,78,111,116,32,105,109,112,111,114,116,105,110, + 103,32,100,105,114,101,99,116,111,114,121,32,123,125,58,32, + 109,105,115,115,105,110,103,32,95,95,105,110,105,116,95,95, + 114,59,0,0,0,41,6,218,11,102,105,110,100,95,108,111, + 97,100,101,114,114,31,0,0,0,114,60,0,0,0,114,61, + 0,0,0,114,47,0,0,0,218,13,73,109,112,111,114,116, + 87,97,114,110,105,110,103,41,5,114,108,0,0,0,218,8, + 102,117,108,108,110,97,109,101,218,6,108,111,97,100,101,114, + 218,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,143,1,0,0,115,10,0,0,0,0,10,21,1,24,1, + 6,1,29,1,114,130,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,240, + 1,0,0,105,0,0,125,4,0,124,2,0,100,1,0,107, + 9,0,114,31,0,124,2,0,124,4,0,100,2,0,60,110, + 6,0,100,3,0,125,2,0,124,3,0,100,1,0,107,9, + 0,114,59,0,124,3,0,124,4,0,100,4,0,60,124,0, + 0,100,1,0,100,5,0,133,2,0,25,125,5,0,124,0, + 0,100,5,0,100,6,0,133,2,0,25,125,6,0,124,0, + 0,100,6,0,100,7,0,133,2,0,25,125,7,0,124,5, + 0,116,0,0,107,3,0,114,168,0,100,8,0,106,1,0, + 124,2,0,124,5,0,131,2,0,125,8,0,116,2,0,100, + 9,0,124,8,0,131,2,0,1,116,3,0,124,8,0,124, + 4,0,141,1,0,130,1,0,110,119,0,116,4,0,124,6, + 0,131,1,0,100,5,0,107,3,0,114,229,0,100,10,0, + 106,1,0,124,2,0,131,1,0,125,8,0,116,2,0,100, + 9,0,124,8,0,131,2,0,1,116,5,0,124,8,0,131, + 1,0,130,1,0,110,58,0,116,4,0,124,7,0,131,1, + 0,100,5,0,107,3,0,114,31,1,100,11,0,106,1,0, + 124,2,0,131,1,0,125,8,0,116,2,0,100,9,0,124, + 8,0,131,2,0,1,116,5,0,124,8,0,131,1,0,130, + 1,0,124,1,0,100,1,0,107,9,0,114,226,1,121,20, + 0,116,6,0,124,1,0,100,12,0,25,131,1,0,125,9, + 0,87,110,18,0,4,116,7,0,107,10,0,114,83,1,1, + 1,1,89,110,62,0,88,116,8,0,124,6,0,131,1,0, + 124,9,0,107,3,0,114,145,1,100,13,0,106,1,0,124, + 2,0,131,1,0,125,8,0,116,2,0,100,9,0,124,8, + 0,131,2,0,1,116,3,0,124,8,0,124,4,0,141,1, + 0,130,1,0,121,18,0,124,1,0,100,14,0,25,100,15, + 0,64,125,10,0,87,110,18,0,4,116,7,0,107,10,0, + 114,183,1,1,1,1,89,110,43,0,88,116,8,0,124,7, + 0,131,1,0,124,10,0,107,3,0,114,226,1,116,3,0, + 100,13,0,106,1,0,124,2,0,131,1,0,124,4,0,141, + 1,0,130,1,0,124,0,0,100,7,0,100,1,0,133,2, + 0,25,83,41,16,97,122,1,0,0,86,97,108,105,100,97, + 116,101,32,116,104,101,32,104,101,97,100,101,114,32,111,102, + 32,116,104,101,32,112,97,115,115,101,100,45,105,110,32,98, + 121,116,101,99,111,100,101,32,97,103,97,105,110,115,116,32, + 115,111,117,114,99,101,95,115,116,97,116,115,32,40,105,102, + 10,32,32,32,32,103,105,118,101,110,41,32,97,110,100,32, + 114,101,116,117,114,110,105,110,103,32,116,104,101,32,98,121, + 116,101,99,111,100,101,32,116,104,97,116,32,99,97,110,32, + 98,101,32,99,111,109,112,105,108,101,100,32,98,121,32,99, + 111,109,112,105,108,101,40,41,46,10,10,32,32,32,32,65, + 108,108,32,111,116,104,101,114,32,97,114,103,117,109,101,110, + 116,115,32,97,114,101,32,117,115,101,100,32,116,111,32,101, + 110,104,97,110,99,101,32,101,114,114,111,114,32,114,101,112, + 111,114,116,105,110,103,46,10,10,32,32,32,32,73,109,112, + 111,114,116,69,114,114,111,114,32,105,115,32,114,97,105,115, + 101,100,32,119,104,101,110,32,116,104,101,32,109,97,103,105, + 99,32,110,117,109,98,101,114,32,105,115,32,105,110,99,111, + 114,114,101,99,116,32,111,114,32,116,104,101,32,98,121,116, + 101,99,111,100,101,32,105,115,10,32,32,32,32,102,111,117, + 110,100,32,116,111,32,98,101,32,115,116,97,108,101,46,32, + 69,79,70,69,114,114,111,114,32,105,115,32,114,97,105,115, + 101,100,32,119,104,101,110,32,116,104,101,32,100,97,116,97, + 32,105,115,32,102,111,117,110,100,32,116,111,32,98,101,10, + 32,32,32,32,116,114,117,110,99,97,116,101,100,46,10,10, + 32,32,32,32,78,114,106,0,0,0,122,10,60,98,121,116, + 101,99,111,100,101,62,114,35,0,0,0,114,12,0,0,0, + 233,8,0,0,0,233,12,0,0,0,122,30,98,97,100,32, + 109,97,103,105,99,32,110,117,109,98,101,114,32,105,110,32, + 123,33,114,125,58,32,123,33,114,125,122,2,123,125,122,43, + 114,101,97,99,104,101,100,32,69,79,70,32,119,104,105,108, + 101,32,114,101,97,100,105,110,103,32,116,105,109,101,115,116, + 97,109,112,32,105,110,32,123,33,114,125,122,48,114,101,97, + 99,104,101,100,32,69,79,70,32,119,104,105,108,101,32,114, + 101,97,100,105,110,103,32,115,105,122,101,32,111,102,32,115, + 111,117,114,99,101,32,105,110,32,123,33,114,125,218,5,109, + 116,105,109,101,122,26,98,121,116,101,99,111,100,101,32,105, + 115,32,115,116,97,108,101,32,102,111,114,32,123,33,114,125, + 218,4,115,105,122,101,108,3,0,0,0,255,127,255,127,3, + 0,41,9,218,12,77,65,71,73,67,95,78,85,77,66,69, + 82,114,47,0,0,0,114,105,0,0,0,114,107,0,0,0, + 114,31,0,0,0,218,8,69,79,70,69,114,114,111,114,114, + 14,0,0,0,218,8,75,101,121,69,114,114,111,114,114,19, + 0,0,0,41,11,114,53,0,0,0,218,12,115,111,117,114, + 99,101,95,115,116,97,116,115,114,106,0,0,0,114,35,0, + 0,0,90,11,101,120,99,95,100,101,116,97,105,108,115,90, + 5,109,97,103,105,99,90,13,114,97,119,95,116,105,109,101, + 115,116,97,109,112,90,8,114,97,119,95,115,105,122,101,114, + 75,0,0,0,218,12,115,111,117,114,99,101,95,109,116,105, + 109,101,218,11,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,160,1,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,13,1,18,1,18,1, + 15,1,13,1,15,1,18,1,15,1,13,1,12,1,12,1, + 3,1,20,1,13,1,5,2,18,1,15,1,13,1,15,1, + 3,1,18,1,13,1,5,2,18,1,15,1,9,1,114,141, + 0,0,0,99,4,0,0,0,0,0,0,0,5,0,0,0, + 6,0,0,0,67,0,0,0,115,112,0,0,0,116,0,0, + 106,1,0,124,0,0,131,1,0,125,4,0,116,2,0,124, + 4,0,116,3,0,131,2,0,114,75,0,116,4,0,100,1, + 0,124,2,0,131,2,0,1,124,3,0,100,2,0,107,9, + 0,114,71,0,116,5,0,106,6,0,124,4,0,124,3,0, + 131,2,0,1,124,4,0,83,116,7,0,100,3,0,106,8, + 0,124,2,0,131,1,0,100,4,0,124,1,0,100,5,0, + 124,2,0,131,1,2,130,1,0,100,2,0,83,41,6,122, + 60,67,111,109,112,105,108,101,32,98,121,116,101,99,111,100, + 101,32,97,115,32,114,101,116,117,114,110,101,100,32,98,121, + 32,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,40,41,46,122,21,99, + 111,100,101,32,111,98,106,101,99,116,32,102,114,111,109,32, + 123,33,114,125,78,122,23,78,111,110,45,99,111,100,101,32, + 111,98,106,101,99,116,32,105,110,32,123,33,114,125,114,106, + 0,0,0,114,35,0,0,0,41,9,218,7,109,97,114,115, + 104,97,108,90,5,108,111,97,100,115,218,10,105,115,105,110, + 115,116,97,110,99,101,218,10,95,99,111,100,101,95,116,121, + 112,101,114,105,0,0,0,218,4,95,105,109,112,90,16,95, + 102,105,120,95,99,111,95,102,105,108,101,110,97,109,101,114, + 107,0,0,0,114,47,0,0,0,41,5,114,53,0,0,0, + 114,106,0,0,0,114,89,0,0,0,114,90,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,215,1,0,0,115,16,0,0,0, + 0,2,15,1,15,1,13,1,12,1,16,1,4,2,18,1, + 114,147,0,0,0,114,59,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,0,0,116,1,0,131,1,0,125,3,0, + 124,3,0,106,2,0,116,3,0,124,1,0,131,1,0,131, + 1,0,1,124,3,0,106,2,0,116,3,0,124,2,0,131, + 1,0,131,1,0,1,124,3,0,106,2,0,116,4,0,106, + 5,0,124,0,0,131,1,0,131,1,0,1,124,3,0,83, + 41,1,122,80,67,111,109,112,105,108,101,32,97,32,99,111, + 100,101,32,111,98,106,101,99,116,32,105,110,116,111,32,98, + 121,116,101,99,111,100,101,32,102,111,114,32,119,114,105,116, + 105,110,103,32,111,117,116,32,116,111,32,97,32,98,121,116, + 101,45,99,111,109,112,105,108,101,100,10,32,32,32,32,102, + 105,108,101,46,41,6,218,9,98,121,116,101,97,114,114,97, + 121,114,135,0,0,0,218,6,101,120,116,101,110,100,114,17, + 0,0,0,114,142,0,0,0,90,5,100,117,109,112,115,41, + 4,114,146,0,0,0,114,133,0,0,0,114,140,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,227,1,0,0,115,10,0,0,0, + 0,3,12,1,19,1,19,1,22,1,114,150,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,116,1,0,106,2,0,124,0,0,131,1, + 0,106,3,0,125,2,0,124,1,0,106,4,0,124,2,0, + 131,1,0,125,3,0,116,1,0,106,5,0,100,2,0,100, + 3,0,131,2,0,125,4,0,124,4,0,106,6,0,124,0, + 0,106,6,0,124,3,0,100,1,0,25,131,1,0,131,1, + 0,83,41,4,122,121,68,101,99,111,100,101,32,98,121,116, + 101,115,32,114,101,112,114,101,115,101,110,116,105,110,103,32, + 115,111,117,114,99,101,32,99,111,100,101,32,97,110,100,32, + 114,101,116,117,114,110,32,116,104,101,32,115,116,114,105,110, + 103,46,10,10,32,32,32,32,85,110,105,118,101,114,115,97, + 108,32,110,101,119,108,105,110,101,32,115,117,112,112,111,114, + 116,32,105,115,32,117,115,101,100,32,105,110,32,116,104,101, + 32,100,101,99,111,100,105,110,103,46,10,32,32,32,32,114, + 59,0,0,0,78,84,41,7,218,8,116,111,107,101,110,105, + 122,101,114,49,0,0,0,90,7,66,121,116,101,115,73,79, + 90,8,114,101,97,100,108,105,110,101,90,15,100,101,116,101, + 99,116,95,101,110,99,111,100,105,110,103,90,25,73,110,99, + 114,101,109,101,110,116,97,108,78,101,119,108,105,110,101,68, + 101,99,111,100,101,114,218,6,100,101,99,111,100,101,41,5, + 218,12,115,111,117,114,99,101,95,98,121,116,101,115,114,151, + 0,0,0,90,21,115,111,117,114,99,101,95,98,121,116,101, + 115,95,114,101,97,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,237,1,0,0,115,10,0,0,0,0,5,12,1, + 18,1,15,1,18,1,114,155,0,0,0,114,127,0,0,0, + 218,26,115,117,98,109,111,100,117,108,101,95,115,101,97,114, + 99,104,95,108,111,99,97,116,105,111,110,115,99,2,0,0, + 0,2,0,0,0,9,0,0,0,19,0,0,0,67,0,0, + 0,115,89,1,0,0,124,1,0,100,1,0,107,8,0,114, + 73,0,100,2,0,125,1,0,116,0,0,124,2,0,100,3, + 0,131,2,0,114,73,0,121,19,0,124,2,0,106,1,0, + 124,0,0,131,1,0,125,1,0,87,110,18,0,4,116,2, + 0,107,10,0,114,72,0,1,1,1,89,110,1,0,88,116, + 3,0,106,4,0,124,0,0,124,2,0,100,4,0,124,1, + 0,131,2,1,125,4,0,100,5,0,124,4,0,95,5,0, + 124,2,0,100,1,0,107,8,0,114,194,0,120,73,0,116, + 6,0,131,0,0,68,93,58,0,92,2,0,125,5,0,125, + 6,0,124,1,0,106,7,0,116,8,0,124,6,0,131,1, + 0,131,1,0,114,128,0,124,5,0,124,0,0,124,1,0, + 131,2,0,125,2,0,124,2,0,124,4,0,95,9,0,80, + 113,128,0,87,100,1,0,83,124,3,0,116,10,0,107,8, + 0,114,23,1,116,0,0,124,2,0,100,6,0,131,2,0, + 114,32,1,121,19,0,124,2,0,106,11,0,124,0,0,131, + 1,0,125,7,0,87,110,18,0,4,116,2,0,107,10,0, + 114,4,1,1,1,1,89,113,32,1,88,124,7,0,114,32, + 1,103,0,0,124,4,0,95,12,0,110,9,0,124,3,0, + 124,4,0,95,12,0,124,4,0,106,12,0,103,0,0,107, + 2,0,114,85,1,124,1,0,114,85,1,116,13,0,124,1, + 0,131,1,0,100,7,0,25,125,8,0,124,4,0,106,12, + 0,106,14,0,124,8,0,131,1,0,1,124,4,0,83,41, + 8,97,61,1,0,0,82,101,116,117,114,110,32,97,32,109, + 111,100,117,108,101,32,115,112,101,99,32,98,97,115,101,100, + 32,111,110,32,97,32,102,105,108,101,32,108,111,99,97,116, + 105,111,110,46,10,10,32,32,32,32,84,111,32,105,110,100, + 105,99,97,116,101,32,116,104,97,116,32,116,104,101,32,109, + 111,100,117,108,101,32,105,115,32,97,32,112,97,99,107,97, + 103,101,44,32,115,101,116,10,32,32,32,32,115,117,98,109, + 111,100,117,108,101,95,115,101,97,114,99,104,95,108,111,99, + 97,116,105,111,110,115,32,116,111,32,97,32,108,105,115,116, + 32,111,102,32,100,105,114,101,99,116,111,114,121,32,112,97, + 116,104,115,46,32,32,65,110,10,32,32,32,32,101,109,112, + 116,121,32,108,105,115,116,32,105,115,32,115,117,102,102,105, + 99,105,101,110,116,44,32,116,104,111,117,103,104,32,105,116, + 115,32,110,111,116,32,111,116,104,101,114,119,105,115,101,32, + 117,115,101,102,117,108,32,116,111,32,116,104,101,10,32,32, + 32,32,105,109,112,111,114,116,32,115,121,115,116,101,109,46, + 10,10,32,32,32,32,84,104,101,32,108,111,97,100,101,114, + 32,109,117,115,116,32,116,97,107,101,32,97,32,115,112,101, + 99,32,97,115,32,105,116,115,32,111,110,108,121,32,95,95, + 105,110,105,116,95,95,40,41,32,97,114,103,46,10,10,32, + 32,32,32,78,122,9,60,117,110,107,110,111,119,110,62,218, + 12,103,101,116,95,102,105,108,101,110,97,109,101,218,6,111, + 114,105,103,105,110,84,218,10,105,115,95,112,97,99,107,97, + 103,101,114,59,0,0,0,41,15,114,115,0,0,0,114,157, + 0,0,0,114,107,0,0,0,114,121,0,0,0,218,10,77, + 111,100,117,108,101,83,112,101,99,90,13,95,115,101,116,95, + 102,105,108,101,97,116,116,114,218,27,95,103,101,116,95,115, + 117,112,112,111,114,116,101,100,95,102,105,108,101,95,108,111, + 97,100,101,114,115,114,92,0,0,0,114,93,0,0,0,114, + 127,0,0,0,218,9,95,80,79,80,85,76,65,84,69,114, + 159,0,0,0,114,156,0,0,0,114,38,0,0,0,218,6, + 97,112,112,101,110,100,41,9,114,106,0,0,0,90,8,108, + 111,99,97,116,105,111,110,114,127,0,0,0,114,156,0,0, + 0,218,4,115,112,101,99,218,12,108,111,97,100,101,114,95, + 99,108,97,115,115,218,8,115,117,102,102,105,120,101,115,114, + 159,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,218,23,115,112, + 101,99,95,102,114,111,109,95,102,105,108,101,95,108,111,99, + 97,116,105,111,110,254,1,0,0,115,60,0,0,0,0,12, + 12,4,6,1,15,2,3,1,19,1,13,1,5,8,24,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,6,1,12,2, + 9,1,15,1,6,1,16,1,16,2,114,167,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,121,0,0,0,101,0,0,90,1,0,100, + 0,0,90,2,0,100,1,0,90,3,0,100,2,0,90,4, + 0,100,3,0,90,5,0,100,4,0,90,6,0,101,7,0, + 100,5,0,100,6,0,132,0,0,131,1,0,90,8,0,101, + 7,0,100,7,0,100,8,0,132,0,0,131,1,0,90,9, + 0,101,7,0,100,9,0,100,9,0,100,10,0,100,11,0, + 132,2,0,131,1,0,90,10,0,101,7,0,100,9,0,100, + 12,0,100,13,0,132,1,0,131,1,0,90,11,0,100,9, + 0,83,41,14,218,21,87,105,110,100,111,119,115,82,101,103, + 105,115,116,114,121,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,109,111,100,117,108,101,115,32,100,101,99,108,97,114, + 101,100,32,105,110,32,116,104,101,32,87,105,110,100,111,119, + 115,32,114,101,103,105,115,116,114,121,46,122,59,83,111,102, + 116,119,97,114,101,92,80,121,116,104,111,110,92,80,121,116, + 104,111,110,67,111,114,101,92,123,115,121,115,95,118,101,114, + 115,105,111,110,125,92,77,111,100,117,108,101,115,92,123,102, + 117,108,108,110,97,109,101,125,122,65,83,111,102,116,119,97, + 114,101,92,80,121,116,104,111,110,92,80,121,116,104,111,110, + 67,111,114,101,92,123,115,121,115,95,118,101,114,115,105,111, + 110,125,92,77,111,100,117,108,101,115,92,123,102,117,108,108, + 110,97,109,101,125,92,68,101,98,117,103,70,99,2,0,0, + 0,0,0,0,0,2,0,0,0,11,0,0,0,67,0,0, + 0,115,67,0,0,0,121,23,0,116,0,0,106,1,0,116, + 0,0,106,2,0,124,1,0,131,2,0,83,87,110,37,0, + 4,116,3,0,107,10,0,114,62,0,1,1,1,116,0,0, + 106,1,0,116,0,0,106,4,0,124,1,0,131,2,0,83, + 89,110,1,0,88,100,0,0,83,41,1,78,41,5,218,7, + 95,119,105,110,114,101,103,90,7,79,112,101,110,75,101,121, + 90,17,72,75,69,89,95,67,85,82,82,69,78,84,95,85, + 83,69,82,114,40,0,0,0,90,18,72,75,69,89,95,76, + 79,67,65,76,95,77,65,67,72,73,78,69,41,2,218,3, + 99,108,115,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,76,2,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,0,6,0,0,0,16,0,0,0,67, + 0,0,0,115,143,0,0,0,124,0,0,106,0,0,114,21, + 0,124,0,0,106,1,0,125,2,0,110,9,0,124,0,0, + 106,2,0,125,2,0,124,2,0,106,3,0,100,1,0,124, + 1,0,100,2,0,116,4,0,106,5,0,100,0,0,100,3, + 0,133,2,0,25,131,0,2,125,3,0,121,47,0,124,0, + 0,106,6,0,124,3,0,131,1,0,143,25,0,125,4,0, + 116,7,0,106,8,0,124,4,0,100,4,0,131,2,0,125, + 5,0,87,100,0,0,81,82,88,87,110,22,0,4,116,9, + 0,107,10,0,114,138,0,1,1,1,100,0,0,83,89,110, + 1,0,88,124,5,0,83,41,5,78,114,126,0,0,0,90, + 11,115,121,115,95,118,101,114,115,105,111,110,114,80,0,0, + 0,114,30,0,0,0,41,10,218,11,68,69,66,85,71,95, + 66,85,73,76,68,218,18,82,69,71,73,83,84,82,89,95, + 75,69,89,95,68,69,66,85,71,218,12,82,69,71,73,83, + 84,82,89,95,75,69,89,114,47,0,0,0,114,7,0,0, + 0,218,7,118,101,114,115,105,111,110,114,172,0,0,0,114, + 169,0,0,0,90,10,81,117,101,114,121,86,97,108,117,101, + 114,40,0,0,0,41,6,114,170,0,0,0,114,126,0,0, + 0,90,12,114,101,103,105,115,116,114,121,95,107,101,121,114, + 171,0,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,83,2,0,0,115,22,0,0,0,0,2, + 9,1,12,2,9,1,15,1,22,1,3,1,18,1,29,1, + 13,1,9,1,122,38,87,105,110,100,111,119,115,82,101,103, + 105,115,116,114,121,70,105,110,100,101,114,46,95,115,101,97, + 114,99,104,95,114,101,103,105,115,116,114,121,78,99,4,0, + 0,0,0,0,0,0,8,0,0,0,14,0,0,0,67,0, + 0,0,115,158,0,0,0,124,0,0,106,0,0,124,1,0, + 131,1,0,125,4,0,124,4,0,100,0,0,107,8,0,114, + 31,0,100,0,0,83,121,14,0,116,1,0,124,4,0,131, + 1,0,1,87,110,22,0,4,116,2,0,107,10,0,114,69, + 0,1,1,1,100,0,0,83,89,110,1,0,88,120,81,0, + 116,3,0,131,0,0,68,93,70,0,92,2,0,125,5,0, + 125,6,0,124,4,0,106,4,0,116,5,0,124,6,0,131, + 1,0,131,1,0,114,80,0,116,6,0,106,7,0,124,1, + 0,124,5,0,124,1,0,124,4,0,131,2,0,100,1,0, + 124,4,0,131,2,1,125,7,0,124,7,0,83,113,80,0, + 87,100,0,0,83,41,2,78,114,158,0,0,0,41,8,114, + 178,0,0,0,114,39,0,0,0,114,40,0,0,0,114,161, + 0,0,0,114,92,0,0,0,114,93,0,0,0,114,121,0, + 0,0,218,16,115,112,101,99,95,102,114,111,109,95,108,111, + 97,100,101,114,41,8,114,170,0,0,0,114,126,0,0,0, + 114,35,0,0,0,218,6,116,97,114,103,101,116,114,177,0, + 0,0,114,127,0,0,0,114,166,0,0,0,114,164,0,0, + 0,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,98,2,0,0,115, + 26,0,0,0,0,2,15,1,12,1,4,1,3,1,14,1, + 13,1,9,1,22,1,21,1,9,1,15,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,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,45,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,9,0,114,37,0,124,3,0,106,1,0,83,100,1, + 0,83,100,1,0,83,41,2,122,108,70,105,110,100,32,109, + 111,100,117,108,101,32,110,97,109,101,100,32,105,110,32,116, + 104,101,32,114,101,103,105,115,116,114,121,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,78,41,2,114,181,0,0,0,114,127, + 0,0,0,41,4,114,170,0,0,0,114,126,0,0,0,114, + 35,0,0,0,114,164,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,114,2,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,112,0,0,0, + 114,111,0,0,0,114,113,0,0,0,114,114,0,0,0,114, + 175,0,0,0,114,174,0,0,0,114,173,0,0,0,218,11, + 99,108,97,115,115,109,101,116,104,111,100,114,172,0,0,0, + 114,178,0,0,0,114,181,0,0,0,114,182,0,0,0,114, + 4,0,0,0,114,4,0,0,0,114,4,0,0,0,114,5, + 0,0,0,114,168,0,0,0,64,2,0,0,115,20,0,0, + 0,12,2,6,3,6,3,6,2,6,2,18,7,18,15,3, + 1,21,15,3,1,114,168,0,0,0,99,0,0,0,0,0, + 0,0,0,0,0,0,0,2,0,0,0,64,0,0,0,115, + 70,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,83,41,11,218,13,95,76, + 111,97,100,101,114,66,97,115,105,99,115,122,83,66,97,115, + 101,32,99,108,97,115,115,32,111,102,32,99,111,109,109,111, + 110,32,99,111,100,101,32,110,101,101,100,101,100,32,98,121, + 32,98,111,116,104,32,83,111,117,114,99,101,76,111,97,100, + 101,114,32,97,110,100,10,32,32,32,32,83,111,117,114,99, + 101,108,101,115,115,70,105,108,101,76,111,97,100,101,114,46, + 99,2,0,0,0,0,0,0,0,5,0,0,0,3,0,0, + 0,67,0,0,0,115,88,0,0,0,116,0,0,124,0,0, + 106,1,0,124,1,0,131,1,0,131,1,0,100,1,0,25, + 125,2,0,124,2,0,106,2,0,100,2,0,100,1,0,131, + 2,0,100,3,0,25,125,3,0,124,1,0,106,3,0,100, + 2,0,131,1,0,100,4,0,25,125,4,0,124,3,0,100, + 5,0,107,2,0,111,87,0,124,4,0,100,5,0,107,3, + 0,83,41,6,122,141,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,105, + 115,95,112,97,99,107,97,103,101,32,98,121,32,99,104,101, + 99,107,105,110,103,32,105,102,10,32,32,32,32,32,32,32, + 32,116,104,101,32,112,97,116,104,32,114,101,116,117,114,110, + 101,100,32,98,121,32,103,101,116,95,102,105,108,101,110,97, + 109,101,32,104,97,115,32,97,32,102,105,108,101,110,97,109, + 101,32,111,102,32,39,95,95,105,110,105,116,95,95,46,112, + 121,39,46,114,29,0,0,0,114,58,0,0,0,114,59,0, + 0,0,114,56,0,0,0,218,8,95,95,105,110,105,116,95, + 95,41,4,114,38,0,0,0,114,157,0,0,0,114,34,0, + 0,0,114,32,0,0,0,41,5,114,108,0,0,0,114,126, + 0,0,0,114,94,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,159,0,0,0,133,2,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,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,108,0,0,0,114,164,0,0,0,114, + 4,0,0,0,114,4,0,0,0,114,5,0,0,0,218,13, + 99,114,101,97,116,101,95,109,111,100,117,108,101,141,2,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,80,0,0,0,124,0,0, + 106,0,0,124,1,0,106,1,0,131,1,0,125,2,0,124, + 2,0,100,1,0,107,8,0,114,54,0,116,2,0,100,2, + 0,106,3,0,124,1,0,106,1,0,131,1,0,131,1,0, + 130,1,0,116,4,0,106,5,0,116,6,0,124,2,0,124, + 1,0,106,7,0,131,3,0,1,100,1,0,83,41,3,122, + 19,69,120,101,99,117,116,101,32,116,104,101,32,109,111,100, + 117,108,101,46,78,122,52,99,97,110,110,111,116,32,108,111, + 97,100,32,109,111,100,117,108,101,32,123,33,114,125,32,119, + 104,101,110,32,103,101,116,95,99,111,100,101,40,41,32,114, + 101,116,117,114,110,115,32,78,111,110,101,41,8,218,8,103, + 101,116,95,99,111,100,101,114,112,0,0,0,114,107,0,0, + 0,114,47,0,0,0,114,121,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,218,4,101,120,101,99,114,118,0,0, + 0,41,3,114,108,0,0,0,218,6,109,111,100,117,108,101, + 114,146,0,0,0,114,4,0,0,0,114,4,0,0,0,114, + 5,0,0,0,218,11,101,120,101,99,95,109,111,100,117,108, + 101,144,2,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,99, + 2,0,0,0,0,0,0,0,2,0,0,0,3,0,0,0, + 67,0,0,0,115,16,0,0,0,116,0,0,106,1,0,124, + 0,0,124,1,0,131,2,0,83,41,1,78,41,2,114,121, + 0,0,0,218,17,95,108,111,97,100,95,109,111,100,117,108, + 101,95,115,104,105,109,41,2,114,108,0,0,0,114,126,0, + 0,0,114,4,0,0,0,114,4,0,0,0,114,5,0,0, + 0,218,11,108,111,97,100,95,109,111,100,117,108,101,152,2, + 0,0,115,2,0,0,0,0,1,122,25,95,76,111,97,100, + 101,114,66,97,115,105,99,115,46,108,111,97,100,95,109,111, + 100,117,108,101,78,41,8,114,112,0,0,0,114,111,0,0, + 0,114,113,0,0,0,114,114,0,0,0,114,159,0,0,0, + 114,186,0,0,0,114,191,0,0,0,114,193,0,0,0,114, + 4,0,0,0,114,4,0,0,0,114,4,0,0,0,114,5, + 0,0,0,114,184,0,0,0,128,2,0,0,115,10,0,0, + 0,12,3,6,2,12,8,12,3,12,8,114,184,0,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,0,0,90,1,0, + 100,0,0,90,2,0,100,1,0,100,2,0,132,0,0,90, + 3,0,100,3,0,100,4,0,132,0,0,90,4,0,100,5, + 0,100,6,0,132,0,0,90,5,0,100,7,0,100,8,0, + 132,0,0,90,6,0,100,9,0,100,10,0,132,0,0,90, + 7,0,100,11,0,100,18,0,100,13,0,100,14,0,132,0, + 1,90,8,0,100,15,0,100,16,0,132,0,0,90,9,0, + 100,17,0,83,41,19,218,12,83,111,117,114,99,101,76,111, + 97,100,101,114,99,2,0,0,0,0,0,0,0,2,0,0, + 0,1,0,0,0,67,0,0,0,115,10,0,0,0,116,0, + 0,130,1,0,100,1,0,83,41,2,122,178,79,112,116,105, + 111,110,97,108,32,109,101,116,104,111,100,32,116,104,97,116, + 32,114,101,116,117,114,110,115,32,116,104,101,32,109,111,100, + 105,102,105,99,97,116,105,111,110,32,116,105,109,101,32,40, + 97,110,32,105,110,116,41,32,102,111,114,32,116,104,101,10, + 32,32,32,32,32,32,32,32,115,112,101,99,105,102,105,101, + 100,32,112,97,116,104,44,32,119,104,101,114,101,32,112,97, + 116,104,32,105,115,32,97,32,115,116,114,46,10,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,78,41, + 1,218,7,73,79,69,114,114,111,114,41,2,114,108,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,2,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,19,0,0,0,100, + 1,0,124,0,0,106,0,0,124,1,0,131,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,133,0,0,0,41,1,114,196,0,0,0,41, + 2,114,108,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,2,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,108,0,0,0,114, + 90,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,2,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,108, + 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,198,0,0, + 0,189,2,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,106,0,0,0,78,41,5,114,157,0, + 0,0,218,8,103,101,116,95,100,97,116,97,114,40,0,0, + 0,114,107,0,0,0,114,155,0,0,0,41,5,114,108,0, + 0,0,114,126,0,0,0,114,35,0,0,0,114,153,0,0, + 0,218,3,101,120,99,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,196,2,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,34,0,0,0,116,0,0,106,1, + 0,116,2,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,189,0,0,0,218,12,100,111,110,116,95,105, + 110,104,101,114,105,116,84,114,68,0,0,0,41,3,114,121, + 0,0,0,114,188,0,0,0,218,7,99,111,109,112,105,108, + 101,41,4,114,108,0,0,0,114,53,0,0,0,114,35,0, + 0,0,114,203,0,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,2,0,0,115,4,0,0,0,0, + 5,21,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,133,0,0,0, + 114,138,0,0,0,114,106,0,0,0,114,35,0,0,0,122, + 13,123,125,32,109,97,116,99,104,101,115,32,123,125,114,89, + 0,0,0,114,90,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,157,0,0,0, + 114,79,0,0,0,114,66,0,0,0,114,197,0,0,0,114, + 195,0,0,0,114,14,0,0,0,114,200,0,0,0,114,40, + 0,0,0,114,141,0,0,0,114,107,0,0,0,114,136,0, + 0,0,114,105,0,0,0,114,147,0,0,0,114,206,0,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,150,0,0,0, + 114,31,0,0,0,114,199,0,0,0,41,10,114,108,0,0, + 0,114,126,0,0,0,114,90,0,0,0,114,139,0,0,0, + 114,89,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,153,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,187,0,0,0, + 214,2,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, + 87,0,0,0,41,10,114,112,0,0,0,114,111,0,0,0, + 114,113,0,0,0,114,196,0,0,0,114,197,0,0,0,114, + 199,0,0,0,114,198,0,0,0,114,202,0,0,0,114,206, + 0,0,0,114,187,0,0,0,114,4,0,0,0,114,4,0, + 0,0,114,4,0,0,0,114,5,0,0,0,114,194,0,0, + 0,156,2,0,0,115,14,0,0,0,12,2,12,8,12,13, + 12,10,12,7,12,10,18,8,114,194,0,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,106,0,0,0,114,35,0,0,0,41,3,114,108,0,0, + 0,114,126,0,0,0,114,35,0,0,0,114,4,0,0,0, + 114,4,0,0,0,114,5,0,0,0,114,185,0,0,0,15, + 3,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,218,9,95,95,99,108,97,115,115,95,95,114,118,0, + 0,0,41,2,114,108,0,0,0,218,5,111,116,104,101,114, + 114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,218, + 6,95,95,101,113,95,95,21,3,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,106,0,0,0,114,35,0,0,0, + 41,1,114,108,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,3,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,210,0,0,0,114,193,0,0,0,41,2,114,108,0, + 0,0,114,126,0,0,0,41,1,114,211,0,0,0,114,4, + 0,0,0,114,5,0,0,0,114,193,0,0,0,28,3,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,108,0,0,0,114,126,0, + 0,0,114,4,0,0,0,114,4,0,0,0,114,5,0,0, + 0,114,157,0,0,0,40,3,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,9,0,0,0,67,0,0,0,115, + 42,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,82,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,108,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, + 200,0,0,0,45,3,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,112,0,0,0,114,111,0, + 0,0,114,113,0,0,0,114,114,0,0,0,114,185,0,0, + 0,114,213,0,0,0,114,215,0,0,0,114,123,0,0,0, + 114,193,0,0,0,114,157,0,0,0,114,200,0,0,0,114, + 4,0,0,0,114,4,0,0,0,41,1,114,211,0,0,0, + 114,5,0,0,0,114,210,0,0,0,10,3,0,0,115,14, + 0,0,0,12,3,6,2,12,6,12,4,12,3,24,12,18, + 5,114,210,0,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,218,16,83,111,117,114,99,101,70,105,108,101,76,111, + 97,100,101,114,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,4,0,0,0,67,0,0,0,115,34,0,0,0,116,0, + 0,124,1,0,131,1,0,125,2,0,100,1,0,124,2,0, + 106,1,0,100,2,0,124,2,0,106,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,133,0,0,0,114,134,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,108,0,0,0, + 114,35,0,0,0,114,208,0,0,0,114,4,0,0,0,114, + 4,0,0,0,114,5,0,0,0,114,197,0,0,0,55,3, + 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,97,0,0,0,114,198,0,0,0,41,5,114,108,0,0, + 0,114,90,0,0,0,114,89,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,199,0,0,0,60,3,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,220,0,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,163,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,105,0,0,0,114,55, + 0,0,0,41,9,114,108,0,0,0,114,35,0,0,0,114, + 53,0,0,0,114,220,0,0,0,218,6,112,97,114,101,110, + 116,114,94,0,0,0,114,27,0,0,0,114,23,0,0,0, + 114,201,0,0,0,114,4,0,0,0,114,4,0,0,0,114, + 5,0,0,0,114,198,0,0,0,65,3,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,112,0,0,0,114,111,0,0,0, + 114,113,0,0,0,114,114,0,0,0,114,197,0,0,0,114, + 199,0,0,0,114,198,0,0,0,114,4,0,0,0,114,4, + 0,0,0,114,4,0,0,0,114,5,0,0,0,114,218,0, + 0,0,51,3,0,0,115,8,0,0,0,12,2,6,2,12, + 5,12,5,114,218,0,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,20,83,111,117,114,99,101,108,101,115,115,70,105, + 108,101,76,111,97,100,101,114,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,106,0,0,0,114,35,0,0,0,114,89,0,0,0,41, + 4,114,157,0,0,0,114,200,0,0,0,114,141,0,0,0, + 114,147,0,0,0,41,5,114,108,0,0,0,114,126,0,0, + 0,114,35,0,0,0,114,53,0,0,0,114,209,0,0,0, + 114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,114, + 187,0,0,0,98,3,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,108,0,0,0,114,126,0,0,0,114, + 4,0,0,0,114,4,0,0,0,114,5,0,0,0,114,202, + 0,0,0,104,3,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,112,0,0,0,114,111,0,0,0,114,113,0,0, + 0,114,114,0,0,0,114,187,0,0,0,114,202,0,0,0, + 114,4,0,0,0,114,4,0,0,0,114,4,0,0,0,114, + 5,0,0,0,114,223,0,0,0,94,3,0,0,115,6,0, + 0,0,12,2,6,2,12,6,114,223,0,0,0,99,0,0, + 0,0,0,0,0,0,0,0,0,0,3,0,0,0,64,0, + 0,0,115,136,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,101,12,0,100,18,0,100, + 19,0,132,0,0,131,1,0,90,13,0,100,20,0,83,41, + 21,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,106,0,0,0,114, + 35,0,0,0,41,3,114,108,0,0,0,114,106,0,0,0, + 114,35,0,0,0,114,4,0,0,0,114,4,0,0,0,114, + 5,0,0,0,114,185,0,0,0,121,3,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,211,0,0,0,114,118,0,0,0,41, + 2,114,108,0,0,0,114,212,0,0,0,114,4,0,0,0, + 114,4,0,0,0,114,5,0,0,0,114,213,0,0,0,125, + 3,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,214,0,0,0,114,106,0,0,0,114,35,0,0,0, + 41,1,114,108,0,0,0,114,4,0,0,0,114,4,0,0, + 0,114,5,0,0,0,114,215,0,0,0,129,3,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,3,0,0, + 0,4,0,0,0,67,0,0,0,115,47,0,0,0,116,0, + 0,106,1,0,116,2,0,106,3,0,124,1,0,131,2,0, + 125,2,0,116,4,0,100,1,0,124,1,0,106,5,0,124, + 0,0,106,6,0,131,3,0,1,124,2,0,83,41,2,122, + 38,67,114,101,97,116,101,32,97,110,32,117,110,105,116,105, + 97,108,105,122,101,100,32,101,120,116,101,110,115,105,111,110, + 32,109,111,100,117,108,101,122,38,101,120,116,101,110,115,105, + 111,110,32,109,111,100,117,108,101,32,123,33,114,125,32,108, + 111,97,100,101,100,32,102,114,111,109,32,123,33,114,125,41, + 7,114,121,0,0,0,114,188,0,0,0,114,145,0,0,0, + 90,14,99,114,101,97,116,101,95,100,121,110,97,109,105,99, + 114,105,0,0,0,114,106,0,0,0,114,35,0,0,0,41, + 3,114,108,0,0,0,114,164,0,0,0,114,190,0,0,0, + 114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,114, + 186,0,0,0,132,3,0,0,115,10,0,0,0,0,2,6, + 1,15,1,6,1,16,1,122,33,69,120,116,101,110,115,105, + 111,110,70,105,108,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,4,0,0,0,67,0,0,0,115, + 45,0,0,0,116,0,0,106,1,0,116,2,0,106,3,0, + 124,1,0,131,2,0,1,116,4,0,100,1,0,124,0,0, + 106,5,0,124,0,0,106,6,0,131,3,0,1,100,2,0, + 83,41,3,122,30,73,110,105,116,105,97,108,105,122,101,32, + 97,110,32,101,120,116,101,110,115,105,111,110,32,109,111,100, + 117,108,101,122,40,101,120,116,101,110,115,105,111,110,32,109, + 111,100,117,108,101,32,123,33,114,125,32,101,120,101,99,117, + 116,101,100,32,102,114,111,109,32,123,33,114,125,78,41,7, + 114,121,0,0,0,114,188,0,0,0,114,145,0,0,0,90, + 12,101,120,101,99,95,100,121,110,97,109,105,99,114,105,0, + 0,0,114,106,0,0,0,114,35,0,0,0,41,2,114,108, + 0,0,0,114,190,0,0,0,114,4,0,0,0,114,4,0, + 0,0,114,5,0,0,0,114,191,0,0,0,140,3,0,0, + 115,6,0,0,0,0,2,19,1,6,1,122,31,69,120,116, + 101,110,115,105,111,110,70,105,108,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,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,185,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,250,9,60,103, + 101,110,101,120,112,114,62,149,3,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,218,3,97,110,121,218,18,69,88,84,69,78,83,73,79, + 78,95,83,85,70,70,73,88,69,83,41,2,114,108,0,0, + 0,114,126,0,0,0,114,4,0,0,0,41,1,114,226,0, + 0,0,114,5,0,0,0,114,159,0,0,0,146,3,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,108,0,0,0,114,126,0,0,0,114,4, + 0,0,0,114,4,0,0,0,114,5,0,0,0,114,187,0, + 0,0,152,3,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,108,0,0,0,114, + 126,0,0,0,114,4,0,0,0,114,4,0,0,0,114,5, + 0,0,0,114,202,0,0,0,156,3,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,108,0,0,0, + 114,126,0,0,0,114,4,0,0,0,114,4,0,0,0,114, + 5,0,0,0,114,157,0,0,0,160,3,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,14,114,112,0,0,0,114,111, + 0,0,0,114,113,0,0,0,114,114,0,0,0,114,185,0, + 0,0,114,213,0,0,0,114,215,0,0,0,114,186,0,0, + 0,114,191,0,0,0,114,159,0,0,0,114,187,0,0,0, + 114,202,0,0,0,114,123,0,0,0,114,157,0,0,0,114, + 4,0,0,0,114,4,0,0,0,114,4,0,0,0,114,5, + 0,0,0,114,224,0,0,0,113,3,0,0,115,20,0,0, + 0,12,6,6,2,12,4,12,4,12,3,12,8,12,6,12, + 6,12,4,12,4,114,224,0,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,218,5,95,110,97,109,101,218,5,95, + 112,97,116,104,114,93,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,108, + 0,0,0,114,106,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,185,0,0,0,173,3, + 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,58,0,0,0,114,30, + 0,0,0,114,7,0,0,0,114,35,0,0,0,90,8,95, + 95,112,97,116,104,95,95,41,2,122,3,115,121,115,122,4, + 112,97,116,104,41,2,114,231,0,0,0,114,32,0,0,0, + 41,4,114,108,0,0,0,114,222,0,0,0,218,3,100,111, + 116,90,2,109,101,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,3,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,238,0,0,0, + 114,117,0,0,0,114,7,0,0,0,218,7,109,111,100,117, + 108,101,115,41,3,114,108,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,233,0, + 0,0,189,3,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,93,0,0,0,114,233,0,0,0,114, + 234,0,0,0,114,235,0,0,0,114,231,0,0,0,114,127, + 0,0,0,114,156,0,0,0,114,232,0,0,0,41,3,114, + 108,0,0,0,90,11,112,97,114,101,110,116,95,112,97,116, + 104,114,164,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,3,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,240, + 0,0,0,41,1,114,108,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,3,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,240,0,0,0, + 41,1,114,108,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, + 3,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,232,0,0, + 0,41,1,114,108,0,0,0,114,4,0,0,0,114,4,0, + 0,0,114,5,0,0,0,218,8,95,95,114,101,112,114,95, + 95,212,3,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,240,0,0,0,41,2,114,108,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,3,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,232, + 0,0,0,114,163,0,0,0,41,2,114,108,0,0,0,114, + 245,0,0,0,114,4,0,0,0,114,4,0,0,0,114,5, + 0,0,0,114,163,0,0,0,218,3,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,112,0, + 0,0,114,111,0,0,0,114,113,0,0,0,114,114,0,0, + 0,114,185,0,0,0,114,238,0,0,0,114,233,0,0,0, + 114,240,0,0,0,114,242,0,0,0,114,243,0,0,0,114, + 244,0,0,0,114,246,0,0,0,114,163,0,0,0,114,4, + 0,0,0,114,4,0,0,0,114,4,0,0,0,114,5,0, + 0,0,114,230,0,0,0,166,3,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,230,0,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,218,16,95,78,97, + 109,101,115,112,97,99,101,76,111,97,100,101,114,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,230,0,0,0,114,232,0,0,0,41, + 4,114,108,0,0,0,114,106,0,0,0,114,35,0,0,0, + 114,236,0,0,0,114,4,0,0,0,114,4,0,0,0,114, + 5,0,0,0,114,185,0,0,0,224,3,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,112,0,0,0,41,2,114,170,0,0,0,114,190, + 0,0,0,114,4,0,0,0,114,4,0,0,0,114,5,0, + 0,0,218,11,109,111,100,117,108,101,95,114,101,112,114,227, + 3,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,108,0,0,0,114,126,0,0,0,114,4,0,0,0, + 114,4,0,0,0,114,5,0,0,0,114,159,0,0,0,236, + 3,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,114,4,0, + 0,0,41,2,114,108,0,0,0,114,126,0,0,0,114,4, + 0,0,0,114,4,0,0,0,114,5,0,0,0,114,202,0, + 0,0,239,3,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,189,0,0, + 0,114,204,0,0,0,84,41,1,114,205,0,0,0,41,2, + 114,108,0,0,0,114,126,0,0,0,114,4,0,0,0,114, + 4,0,0,0,114,5,0,0,0,114,187,0,0,0,242,3, + 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,108,0,0,0,114,164,0, + 0,0,114,4,0,0,0,114,4,0,0,0,114,5,0,0, + 0,114,186,0,0,0,245,3,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,108,0,0,0,114,190,0,0, + 0,114,4,0,0,0,114,4,0,0,0,114,5,0,0,0, + 114,191,0,0,0,248,3,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,32,0,0,0,116,0,0,100,1,0,124,0, + 0,106,1,0,131,2,0,1,116,2,0,106,3,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,4,114,105,0,0,0,114,232,0, + 0,0,114,121,0,0,0,114,192,0,0,0,41,2,114,108, + 0,0,0,114,126,0,0,0,114,4,0,0,0,114,4,0, + 0,0,114,5,0,0,0,114,193,0,0,0,251,3,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,112,0,0,0,114, + 111,0,0,0,114,113,0,0,0,114,185,0,0,0,114,183, + 0,0,0,114,248,0,0,0,114,159,0,0,0,114,202,0, + 0,0,114,187,0,0,0,114,186,0,0,0,114,191,0,0, + 0,114,193,0,0,0,114,4,0,0,0,114,4,0,0,0, + 114,4,0,0,0,114,5,0,0,0,114,247,0,0,0,223, + 3,0,0,115,16,0,0,0,12,1,12,3,18,9,12,3, + 12,3,12,3,12,3,12,3,114,247,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, + 115,0,0,0,114,250,0,0,0,41,2,114,170,0,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,250,0,0,0,12,4,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,60,0,0,0,114,61,0,0,0,114,125,0,0,0,114, + 107,0,0,0,41,3,114,170,0,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,4,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,251,0,0,0,114,137,0, + 0,0,114,255,0,0,0,41,3,114,170,0,0,0,114,35, + 0,0,0,114,253,0,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,4,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,119,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,88,0,116, + 3,0,106,4,0,124,1,0,124,3,0,131,2,0,83,116, + 3,0,106,5,0,124,1,0,100,0,0,131,2,0,125,5, + 0,124,4,0,124,5,0,95,6,0,124,5,0,83,41,2, + 78,114,124,0,0,0,41,7,114,115,0,0,0,114,124,0, + 0,0,114,182,0,0,0,114,121,0,0,0,114,179,0,0, + 0,114,160,0,0,0,114,156,0,0,0,41,6,114,170,0, + 0,0,114,126,0,0,0,114,253,0,0,0,114,127,0,0, + 0,114,128,0,0,0,114,164,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,4,0,0, + 115,18,0,0,0,0,4,15,1,24,2,15,1,6,1,12, + 1,16,1,18,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,243,0,0,0,103, + 0,0,125,4,0,120,230,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,106,12,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,181,0,0,0,122,19,115,112,101, + 99,32,109,105,115,115,105,110,103,32,108,111,97,100,101,114, + 41,13,114,143,0,0,0,114,69,0,0,0,218,5,98,121, + 116,101,115,114,1,1,0,0,114,115,0,0,0,114,181,0, + 0,0,114,2,1,0,0,114,127,0,0,0,114,156,0,0, + 0,114,107,0,0,0,114,149,0,0,0,114,121,0,0,0, + 114,160,0,0,0,41,9,114,170,0,0,0,114,126,0,0, + 0,114,35,0,0,0,114,180,0,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,253,0,0,0,114,164,0,0,0,114,128,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,4,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,18,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,5,1,0,0,114,127,0,0,0, + 114,156,0,0,0,114,158,0,0,0,114,230,0,0,0,41, + 6,114,170,0,0,0,114,126,0,0,0,114,35,0,0,0, + 114,180,0,0,0,114,164,0,0,0,114,4,1,0,0,114, + 4,0,0,0,114,4,0,0,0,114,5,0,0,0,114,181, + 0,0,0,106,4,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,181,0,0,0,114,127,0,0,0,41,4,114,170,0,0, + 0,114,126,0,0,0,114,35,0,0,0,114,164,0,0,0, + 114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,114, + 182,0,0,0,128,4,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, + 112,0,0,0,114,111,0,0,0,114,113,0,0,0,114,114, + 0,0,0,114,183,0,0,0,114,250,0,0,0,114,255,0, + 0,0,114,1,1,0,0,114,2,1,0,0,114,5,1,0, + 0,114,181,0,0,0,114,182,0,0,0,114,4,0,0,0, + 114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,114, + 249,0,0,0,8,4,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,249,0,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,225,0,0,0,41,1, + 114,127,0,0,0,114,4,0,0,0,114,5,0,0,0,114, + 227,0,0,0,157,4,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,58,0,0,0,114,29,0,0, + 0,78,114,87,0,0,0,41,7,114,149,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,108,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,166,0,0,0,114,4,0,0,0, + 41,1,114,127,0,0,0,114,5,0,0,0,114,185,0,0, + 0,151,4,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, + 87,0,0,0,41,1,114,8,1,0,0,41,1,114,108,0, + 0,0,114,4,0,0,0,114,4,0,0,0,114,5,0,0, + 0,114,250,0,0,0,165,4,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,181,0,0,0,114,127,0,0,0,114,156,0,0,0,41, + 3,114,108,0,0,0,114,126,0,0,0,114,164,0,0,0, + 114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,114, + 124,0,0,0,171,4,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,127,0,0,0,114,156,0,0,0,41,1,114,167, + 0,0,0,41,7,114,108,0,0,0,114,165,0,0,0,114, + 126,0,0,0,114,35,0,0,0,90,4,115,109,115,108,114, + 180,0,0,0,114,127,0,0,0,114,4,0,0,0,114,4, + 0,0,0,114,5,0,0,0,114,5,1,0,0,183,4,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,234,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,230,1,116,18, + 0,100,9,0,106,19,0,124,8,0,131,1,0,131,1,0, + 1,116,20,0,106,21,0,124,1,0,100,8,0,131,2,0, + 125,13,0,124,8,0,103,1,0,124,13,0,95,22,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,58,0,0,0,114,56, + 0,0,0,114,29,0,0,0,114,185,0,0,0,122,9,116, + 114,121,105,110,103,32,123,125,114,98,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,87,0,0,0,41,23, + 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,219,0,0,0,114,40, + 0,0,0,114,8,1,0,0,218,11,95,102,105,108,108,95, + 99,97,99,104,101,114,6,0,0,0,114,11,1,0,0,114, + 88,0,0,0,114,10,1,0,0,114,28,0,0,0,114,7, + 1,0,0,114,44,0,0,0,114,5,1,0,0,114,46,0, + 0,0,114,105,0,0,0,114,47,0,0,0,114,121,0,0, + 0,114,160,0,0,0,114,156,0,0,0,41,14,114,108,0, + 0,0,114,126,0,0,0,114,180,0,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,133,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,225,0,0, + 0,114,165,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,164,0,0,0,114,4,0,0,0,114,4,0,0,0,114, + 5,0,0,0,114,181,0,0,0,188,4,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, + 18,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,58, + 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,88,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,5,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,0,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,9,1,0,0, + 114,10,1,0,0,114,83,0,0,0,114,47,0,0,0,114, + 88,0,0,0,218,3,97,100,100,114,10,0,0,0,114,11, + 1,0,0,41,9,114,108,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,245,0,0,0,114,106,0,0,0,114,237,0,0,0,114, + 225,0,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,13,1, + 0,0,233,4,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,107,0,0,0,41,1,114,35,0,0, + 0,41,2,114,170,0,0,0,114,12,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,5,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, + 170,0,0,0,114,12,1,0,0,114,18,1,0,0,114,4, + 0,0,0,41,2,114,170,0,0,0,114,12,1,0,0,114, + 5,0,0,0,218,9,112,97,116,104,95,104,111,111,107,8, + 5,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, + 108,0,0,0,114,4,0,0,0,114,4,0,0,0,114,5, + 0,0,0,114,244,0,0,0,26,5,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,112,0,0,0,114, + 111,0,0,0,114,113,0,0,0,114,114,0,0,0,114,185, + 0,0,0,114,250,0,0,0,114,130,0,0,0,114,182,0, + 0,0,114,124,0,0,0,114,5,1,0,0,114,181,0,0, + 0,114,13,1,0,0,114,183,0,0,0,114,19,1,0,0, + 114,244,0,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,142,4, + 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,6,1,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,124,0,0,106,0,0,100, + 2,0,131,1,0,125,5,0,124,4,0,115,99,0,124,5, + 0,114,54,0,124,5,0,106,1,0,125,4,0,110,45,0, + 124,2,0,124,3,0,107,2,0,114,84,0,116,2,0,124, + 1,0,124,2,0,131,2,0,125,4,0,110,15,0,116,3, + 0,124,1,0,124,2,0,131,2,0,125,4,0,124,5,0, + 115,126,0,116,4,0,124,1,0,124,2,0,100,3,0,124, + 4,0,131,2,1,125,5,0,121,44,0,124,5,0,124,0, + 0,100,2,0,60,124,4,0,124,0,0,100,1,0,60,124, + 2,0,124,0,0,100,4,0,60,124,3,0,124,0,0,100, + 5,0,60,87,110,18,0,4,116,5,0,107,10,0,114,190, + 0,1,1,1,89,110,1,0,88,100,0,0,83,41,6,78, + 218,10,95,95,108,111,97,100,101,114,95,95,218,8,95,95, + 115,112,101,99,95,95,114,127,0,0,0,90,8,95,95,102, + 105,108,101,95,95,90,10,95,95,99,97,99,104,101,100,95, + 95,41,6,218,3,103,101,116,114,127,0,0,0,114,223,0, + 0,0,114,218,0,0,0,114,167,0,0,0,218,9,69,120, + 99,101,112,116,105,111,110,41,6,90,2,110,115,114,106,0, + 0,0,90,8,112,97,116,104,110,97,109,101,90,9,99,112, + 97,116,104,110,97,109,101,114,127,0,0,0,114,164,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, + 32,5,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,24,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,224,0,0,0,114,145,0,0,0, + 218,18,101,120,116,101,110,115,105,111,110,95,115,117,102,102, + 105,120,101,115,114,218,0,0,0,114,84,0,0,0,114,223, + 0,0,0,114,74,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,161,0,0,0,55,5,0,0, + 115,8,0,0,0,0,5,18,1,12,1,12,1,114,161,0, + 0,0,99,1,0,0,0,0,0,0,0,12,0,0,0,12, + 0,0,0,67,0,0,0,115,70,2,0,0,124,0,0,97, + 0,0,116,0,0,106,1,0,97,1,0,116,0,0,106,2, + 0,97,2,0,116,1,0,106,3,0,116,4,0,25,125,1, + 0,120,76,0,100,26,0,68,93,68,0,125,2,0,124,2, + 0,116,1,0,106,3,0,107,7,0,114,83,0,116,0,0, + 106,5,0,124,2,0,131,1,0,125,3,0,110,13,0,116, + 1,0,106,3,0,124,2,0,25,125,3,0,116,6,0,124, + 1,0,124,2,0,124,3,0,131,3,0,1,113,44,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,4, + 0,120,149,0,124,4,0,68,93,129,0,92,2,0,125,5, + 0,125,6,0,116,7,0,100,9,0,100,10,0,132,0,0, + 124,6,0,68,131,1,0,131,1,0,115,199,0,116,8,0, + 130,1,0,124,6,0,100,11,0,25,125,7,0,124,5,0, + 116,1,0,106,3,0,107,6,0,114,241,0,116,1,0,106, + 3,0,124,5,0,25,125,8,0,80,113,156,0,121,20,0, + 116,0,0,106,5,0,124,5,0,131,1,0,125,8,0,80, + 87,113,156,0,4,116,9,0,107,10,0,114,28,1,1,1, + 1,119,156,0,89,113,156,0,88,113,156,0,87,116,9,0, + 100,12,0,131,1,0,130,1,0,116,6,0,124,1,0,100, + 13,0,124,8,0,131,3,0,1,116,6,0,124,1,0,100, + 14,0,124,7,0,131,3,0,1,116,6,0,124,1,0,100, + 15,0,100,16,0,106,10,0,124,6,0,131,1,0,131,3, + 0,1,121,19,0,116,0,0,106,5,0,100,17,0,131,1, + 0,125,9,0,87,110,24,0,4,116,9,0,107,10,0,114, + 147,1,1,1,1,100,18,0,125,9,0,89,110,1,0,88, + 116,6,0,124,1,0,100,17,0,124,9,0,131,3,0,1, + 116,0,0,106,5,0,100,19,0,131,1,0,125,10,0,116, + 6,0,124,1,0,100,19,0,124,10,0,131,3,0,1,124, + 5,0,100,7,0,107,2,0,114,238,1,116,0,0,106,5, + 0,100,20,0,131,1,0,125,11,0,116,6,0,124,1,0, + 100,21,0,124,11,0,131,3,0,1,116,6,0,124,1,0, + 100,22,0,116,11,0,131,0,0,131,3,0,1,116,12,0, + 106,13,0,116,2,0,106,14,0,131,0,0,131,1,0,1, + 124,5,0,100,7,0,107,2,0,114,66,2,116,15,0,106, + 16,0,100,23,0,131,1,0,1,100,24,0,116,12,0,107, + 6,0,114,66,2,100,25,0,116,17,0,95,18,0,100,18, + 0,83,41,27,122,205,83,101,116,117,112,32,116,104,101,32, + 112,97,116,104,45,98,97,115,101,100,32,105,109,112,111,114, + 116,101,114,115,32,102,111,114,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,10,32,32,32,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,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,79, + 116,104,101,114,32,99,111,109,112,111,110,101,110,116,115,32, + 97,114,101,32,101,120,116,114,97,99,116,101,100,32,102,114, + 111,109,32,116,104,101,32,99,111,114,101,32,98,111,111,116, + 115,116,114,97,112,32,109,111,100,117,108,101,46,10,10,32, + 32,32,32,114,49,0,0,0,114,60,0,0,0,218,8,98, + 117,105,108,116,105,110,115,114,142,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,77, + 0,0,0,114,4,0,0,0,114,4,0,0,0,114,5,0, + 0,0,114,227,0,0,0,91,5,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,59,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,90,7,95,116,104,114,101,97,100,78, + 90,8,95,119,101,97,107,114,101,102,90,6,119,105,110,114, + 101,103,114,169,0,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,19,114,121,0,0,0,114,7,0,0,0,114,145,0,0, + 0,114,239,0,0,0,114,112,0,0,0,90,18,95,98,117, + 105,108,116,105,110,95,102,114,111,109,95,110,97,109,101,114, + 116,0,0,0,218,3,97,108,108,218,14,65,115,115,101,114, + 116,105,111,110,69,114,114,111,114,114,107,0,0,0,114,26, + 0,0,0,114,11,0,0,0,114,229,0,0,0,114,149,0, + 0,0,114,25,1,0,0,114,84,0,0,0,114,163,0,0, + 0,114,168,0,0,0,114,173,0,0,0,41,12,218,17,95, + 98,111,111,116,115,116,114,97,112,95,109,111,100,117,108,101, + 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,66,5,0, + 0,115,82,0,0,0,0,8,6,1,9,1,9,3,13,1, + 13,1,15,1,18,2,13,1,20,3,33,1,19,2,31,1, + 10,1,15,1,13,1,4,2,3,1,15,1,5,1,13,1, + 12,2,12,1,16,1,16,1,25,3,3,1,19,1,13,2, + 11,1,16,3,15,1,16,3,12,1,15,1,16,3,19,1, + 19,1,12,1,13,1,12,1,114,33,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,116,0,0,0,116,0,0,124,0,0,131,1,0, + 1,116,1,0,131,0,0,125,1,0,116,2,0,106,3,0, + 106,4,0,116,5,0,106,6,0,124,1,0,140,0,0,103, + 1,0,131,1,0,1,116,7,0,106,8,0,100,1,0,107, + 2,0,114,78,0,116,2,0,106,9,0,106,10,0,116,11, + 0,131,1,0,1,116,2,0,106,9,0,106,10,0,116,12, + 0,131,1,0,1,116,5,0,124,0,0,95,5,0,116,13, + 0,124,0,0,95,13,0,100,2,0,83,41,3,122,41,73, + 110,115,116,97,108,108,32,116,104,101,32,112,97,116,104,45, + 98,97,115,101,100,32,105,109,112,111,114,116,32,99,111,109, + 112,111,110,101,110,116,115,46,114,28,1,0,0,78,41,14, + 114,33,1,0,0,114,161,0,0,0,114,7,0,0,0,114, + 254,0,0,0,114,149,0,0,0,114,6,1,0,0,114,19, + 1,0,0,114,3,0,0,0,114,112,0,0,0,218,9,109, + 101,116,97,95,112,97,116,104,114,163,0,0,0,114,168,0, + 0,0,114,249,0,0,0,114,218,0,0,0,41,2,114,32, + 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,134, + 5,0,0,115,16,0,0,0,0,2,10,1,9,1,28,1, + 15,1,16,1,16,4,9,1,114,35,1,0,0,41,3,122, + 3,119,105,110,114,1,0,0,0,114,2,0,0,0,41,57, + 114,114,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,218,4,116,121, + 112,101,218,8,95,95,99,111,100,101,95,95,114,144,0,0, + 0,114,15,0,0,0,114,135,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,73,0,0,0,114,72,0, + 0,0,114,84,0,0,0,114,74,0,0,0,90,23,68,69, + 66,85,71,95,66,89,84,69,67,79,68,69,95,83,85,70, + 70,73,88,69,83,90,27,79,80,84,73,77,73,90,69,68, + 95,66,89,84,69,67,79,68,69,95,83,85,70,70,73,88, + 69,83,114,79,0,0,0,114,85,0,0,0,114,91,0,0, + 0,114,95,0,0,0,114,97,0,0,0,114,105,0,0,0, + 114,123,0,0,0,114,130,0,0,0,114,141,0,0,0,114, + 147,0,0,0,114,150,0,0,0,114,155,0,0,0,218,6, + 111,98,106,101,99,116,114,162,0,0,0,114,167,0,0,0, + 114,168,0,0,0,114,184,0,0,0,114,194,0,0,0,114, + 210,0,0,0,114,218,0,0,0,114,223,0,0,0,114,229, + 0,0,0,114,224,0,0,0,114,230,0,0,0,114,247,0, + 0,0,114,249,0,0,0,114,6,1,0,0,114,24,1,0, + 0,114,161,0,0,0,114,33,1,0,0,114,35,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,100,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,15, + 110,22,1,18,2,6,1,6,2,9,2,9,2,10,2,21, + 44,12,33,12,19,12,12,12,12,18,8,12,28,12,17,21, + 55,21,12,18,10,12,14,9,3,12,1,15,65,19,64,19, + 28,22,110,19,41,25,43,25,16,6,3,25,53,19,57,19, + 41,19,134,19,146,15,23,12,11,12,68, +}; diff --git a/Python/marshal.c b/Python/marshal.c index 6f0ee5e83e..f89cd04b65 100644 --- a/Python/marshal.c +++ b/Python/marshal.c @@ -12,8 +12,7 @@ #include "longintrepr.h" #include "code.h" #include "marshal.h" - -#define ABS(x) ((x) < 0 ? -(x) : (x)) +#include "../Modules/hashtable.h" /* High water mark to determine when the marshalled object is dangerously deep * and risks coring the interpreter. When the object stack gets this deep, @@ -21,7 +20,7 @@ * On Windows debug builds, reduce this value. */ #if defined(MS_WINDOWS) && defined(_DEBUG) -#define MAX_MARSHAL_STACK_DEPTH 1500 +#define MAX_MARSHAL_STACK_DEPTH 1000 #else #define MAX_MARSHAL_STACK_DEPTH 2000 #endif @@ -66,54 +65,83 @@ typedef struct { FILE *fp; int error; /* see WFERR_* values */ int depth; - /* If fp == NULL, the following are valid: */ - PyObject *readable; /* Stream-like object being read from */ PyObject *str; - PyObject *current_filename; char *ptr; char *end; char *buf; - Py_ssize_t buf_size; - PyObject *refs; /* dict on marshal, list on unmarshal */ + _Py_hashtable_t *hashtable; int version; } WFILE; -#define w_byte(c, p) if (((p)->fp)) putc((c), (p)->fp); \ - else if ((p)->ptr != (p)->end) *(p)->ptr++ = (c); \ - else w_more((c), p) +#define w_byte(c, p) do { \ + if ((p)->ptr != (p)->end || w_reserve((p), 1)) \ + *(p)->ptr++ = (c); \ + } while(0) static void -w_more(char c, WFILE *p) +w_flush(WFILE *p) +{ + assert(p->fp != NULL); + fwrite(p->buf, 1, p->ptr - p->buf, p->fp); + p->ptr = p->buf; +} + +static int +w_reserve(WFILE *p, Py_ssize_t needed) { - Py_ssize_t size, newsize; - if (p->str == NULL) - return; /* An error already occurred */ + Py_ssize_t pos, size, delta; + if (p->ptr == NULL) + return 0; /* An error already occurred */ + if (p->fp != NULL) { + w_flush(p); + return needed <= p->end - p->ptr; + } + assert(p->str != NULL); + pos = p->ptr - p->buf; size = PyBytes_Size(p->str); - newsize = size + size + 1024; - if (newsize > 32*1024*1024) { - newsize = size + (size >> 3); /* 12.5% overallocation */ + if (size > 16*1024*1024) + delta = (size >> 3); /* 12.5% overallocation */ + else + delta = size + 1024; + delta = Py_MAX(delta, needed); + if (delta > PY_SSIZE_T_MAX - size) { + p->error = WFERR_NOMEMORY; + return 0; } - if (_PyBytes_Resize(&p->str, newsize) != 0) { - p->ptr = p->end = NULL; + size += delta; + if (_PyBytes_Resize(&p->str, size) != 0) { + p->ptr = p->buf = p->end = NULL; + return 0; } else { - p->ptr = PyBytes_AS_STRING((PyBytesObject *)p->str) + size; - p->end = - PyBytes_AS_STRING((PyBytesObject *)p->str) + newsize; - *p->ptr++ = c; + p->buf = PyBytes_AS_STRING(p->str); + p->ptr = p->buf + pos; + p->end = p->buf + size; + return 1; } } static void w_string(const char *s, Py_ssize_t n, WFILE *p) { + Py_ssize_t m; + if (!n || p->ptr == NULL) + return; + m = p->end - p->ptr; if (p->fp != NULL) { - fwrite(s, 1, n, p->fp); + if (n <= m) { + Py_MEMCPY(p->ptr, s, n); + p->ptr += n; + } + else { + w_flush(p); + fwrite(s, 1, n, p->fp); + } } else { - while (--n >= 0) { - w_byte(*s, p); - s++; + if (n <= m || w_reserve(p, n - m)) { + Py_MEMCPY(p->ptr, s, n); + p->ptr += n; } } } @@ -192,7 +220,7 @@ w_PyLong(const PyLongObject *ob, char flag, WFILE *p) } /* set l to number of base PyLong_MARSHAL_BASE digits */ - n = ABS(Py_SIZE(ob)); + n = Py_ABS(Py_SIZE(ob)); l = (n-1) * PyLong_MARSHAL_RATIO; d = ob->ob_digit[n-1]; assert(d != 0); /* a PyLong is always normalized */ @@ -225,46 +253,38 @@ w_PyLong(const PyLongObject *ob, char flag, WFILE *p) static int w_ref(PyObject *v, char *flag, WFILE *p) { - PyObject *id; - PyObject *idx; + _Py_hashtable_entry_t *entry; + int w; - if (p->version < 3 || p->refs == NULL) + if (p->version < 3 || p->hashtable == NULL) return 0; /* not writing object references */ /* if it has only one reference, it definitely isn't shared */ if (Py_REFCNT(v) == 1) return 0; - id = PyLong_FromVoidPtr((void*)v); - if (id == NULL) - goto err; - idx = PyDict_GetItem(p->refs, id); - if (idx != NULL) { + entry = _Py_hashtable_get_entry(p->hashtable, v); + if (entry != NULL) { /* write the reference index to the stream */ - long w = PyLong_AsLong(idx); - Py_DECREF(id); - if (w == -1 && PyErr_Occurred()) { - goto err; - } + _Py_HASHTABLE_ENTRY_READ_DATA(p->hashtable, &w, sizeof(w), entry); /* we don't store "long" indices in the dict */ assert(0 <= w && w <= 0x7fffffff); w_byte(TYPE_REF, p); w_long(w, p); return 1; } else { - int ok; - Py_ssize_t s = PyDict_Size(p->refs); + size_t s = p->hashtable->entries; /* we don't support long indices */ if (s >= 0x7fffffff) { PyErr_SetString(PyExc_ValueError, "too many objects"); goto err; } - idx = PyLong_FromSsize_t(s); - ok = idx && PyDict_SetItem(p->refs, id, idx) == 0; - Py_DECREF(id); - Py_XDECREF(idx); - if (!ok) + w = (int)s; + Py_INCREF(v); + if (_Py_HASHTABLE_SET(p->hashtable, v, w) < 0) { + Py_DECREF(v); goto err; + } *flag |= FLAG_REF; return 0; } @@ -547,37 +567,81 @@ w_complex_object(PyObject *v, char flag, WFILE *p) } } +static int +w_init_refs(WFILE *wf, int version) +{ + if (version >= 3) { + wf->hashtable = _Py_hashtable_new(sizeof(int), _Py_hashtable_hash_ptr, + _Py_hashtable_compare_direct); + if (wf->hashtable == NULL) { + PyErr_NoMemory(); + return -1; + } + } + return 0; +} + +static int +w_decref_entry(_Py_hashtable_entry_t *entry, void *Py_UNUSED(data)) +{ + Py_XDECREF(entry->key); + return 0; +} + +static void +w_clear_refs(WFILE *wf) +{ + if (wf->hashtable != NULL) { + _Py_hashtable_foreach(wf->hashtable, w_decref_entry, NULL); + _Py_hashtable_destroy(wf->hashtable); + } +} + /* version currently has no effect for writing ints. */ void PyMarshal_WriteLongToFile(long x, FILE *fp, int version) { + char buf[4]; WFILE wf; + memset(&wf, 0, sizeof(wf)); wf.fp = fp; + wf.ptr = wf.buf = buf; + wf.end = wf.ptr + sizeof(buf); wf.error = WFERR_OK; - wf.depth = 0; - wf.refs = NULL; wf.version = version; w_long(x, &wf); + w_flush(&wf); } void PyMarshal_WriteObjectToFile(PyObject *x, FILE *fp, int version) { + char buf[BUFSIZ]; WFILE wf; + memset(&wf, 0, sizeof(wf)); wf.fp = fp; + wf.ptr = wf.buf = buf; + wf.end = wf.ptr + sizeof(buf); wf.error = WFERR_OK; - wf.depth = 0; - if (version >= 3) { - if ((wf.refs = PyDict_New()) == NULL) - return; /* caller mush check PyErr_Occurred() */ - } else - wf.refs = NULL; wf.version = version; + if (w_init_refs(&wf, version)) + return; /* caller mush check PyErr_Occurred() */ w_object(x, &wf); - Py_XDECREF(wf.refs); + w_clear_refs(&wf); + w_flush(&wf); } -typedef WFILE RFILE; /* Same struct with different invariants */ +typedef struct { + FILE *fp; + int depth; + PyObject *readable; /* Stream-like object being read from */ + PyObject *current_filename; + char *ptr; + char *end; + char *buf; + Py_ssize_t buf_size; + PyObject *refs; /* a list */ +} RFILE; static char * r_string(Py_ssize_t n, RFILE *p) @@ -727,8 +791,8 @@ r_PyLong(RFILE *p) return NULL; } - size = 1 + (ABS(n) - 1) / PyLong_MARSHAL_RATIO; - shorts_in_top_digit = 1 + (ABS(n) - 1) % PyLong_MARSHAL_RATIO; + size = 1 + (Py_ABS(n) - 1) / PyLong_MARSHAL_RATIO; + shorts_in_top_digit = 1 + (Py_ABS(n) - 1) % PyLong_MARSHAL_RATIO; ob = _PyLong_New(size); if (ob == NULL) return NULL; @@ -1417,18 +1481,20 @@ PyMarshal_ReadLongFromFile(FILE *fp) return res; } -#ifdef HAVE_FSTAT -/* Return size of file in bytes; < 0 if unknown. */ +/* Return size of file in bytes; < 0 if unknown or INT_MAX if too big */ static off_t getfilesize(FILE *fp) { - struct stat st; - if (fstat(fileno(fp), &st) != 0) + struct _Py_stat_struct st; + if (_Py_fstat_noraise(fileno(fp), &st) != 0) return -1; +#if SIZEOF_OFF_T == 4 + else if (st.st_size >= INT_MAX) + return (off_t)INT_MAX; +#endif else - return st.st_size; + return (off_t)st.st_size; } -#endif /* If we can get the size of the file up-front, and it's reasonably small, * read it in one gulp and delegate to ...FromString() instead. Much quicker @@ -1441,7 +1507,6 @@ PyMarshal_ReadLastObjectFromFile(FILE *fp) { /* REASONABLE_FILE_LIMIT is by defn something big enough for Tkinter.pyc. */ #define REASONABLE_FILE_LIMIT (1L << 18) -#ifdef HAVE_FSTAT off_t filesize; filesize = getfilesize(fp); if (filesize > 0 && filesize <= REASONABLE_FILE_LIMIT) { @@ -1454,7 +1519,6 @@ PyMarshal_ReadLastObjectFromFile(FILE *fp) } } -#endif /* We don't have fstat, or we do but the file is larger than * REASONABLE_FILE_LIMIT or malloc failed -- read a byte at a time. */ @@ -1511,25 +1575,20 @@ PyMarshal_WriteObjectToString(PyObject *x, int version) { WFILE wf; - wf.fp = NULL; - wf.readable = NULL; + memset(&wf, 0, sizeof(wf)); wf.str = PyBytes_FromStringAndSize((char *)NULL, 50); if (wf.str == NULL) return NULL; - wf.ptr = PyBytes_AS_STRING((PyBytesObject *)wf.str); + wf.ptr = wf.buf = PyBytes_AS_STRING((PyBytesObject *)wf.str); wf.end = wf.ptr + PyBytes_Size(wf.str); wf.error = WFERR_OK; - wf.depth = 0; wf.version = version; - if (version >= 3) { - if ((wf.refs = PyDict_New()) == NULL) { - Py_DECREF(wf.str); - return NULL; - } - } else - wf.refs = NULL; + if (w_init_refs(&wf, version)) { + Py_DECREF(wf.str); + return NULL; + } w_object(x, &wf); - Py_XDECREF(wf.refs); + w_clear_refs(&wf); if (wf.str != NULL) { char *base = PyBytes_AS_STRING((PyBytesObject *)wf.str); if (wf.ptr - base > PY_SSIZE_T_MAX) { diff --git a/Python/opcode_targets.h b/Python/opcode_targets.h index f90a17a7ee..19259e1a71 100644 --- a/Python/opcode_targets.h +++ b/Python/opcode_targets.h @@ -15,8 +15,8 @@ static void *opcode_targets[256] = { &&_unknown_opcode, &&_unknown_opcode, &&TARGET_UNARY_INVERT, - &&_unknown_opcode, - &&_unknown_opcode, + &&TARGET_BINARY_MATRIX_MULTIPLY, + &&TARGET_INPLACE_MATRIX_MULTIPLY, &&_unknown_opcode, &&TARGET_BINARY_POWER, &&TARGET_BINARY_MULTIPLY, @@ -49,11 +49,11 @@ static void *opcode_targets[256] = { &&_unknown_opcode, &&_unknown_opcode, &&_unknown_opcode, + &&TARGET_GET_AITER, + &&TARGET_GET_ANEXT, + &&TARGET_BEFORE_ASYNC_WITH, &&_unknown_opcode, &&_unknown_opcode, - &&_unknown_opcode, - &&_unknown_opcode, - &&TARGET_STORE_MAP, &&TARGET_INPLACE_ADD, &&TARGET_INPLACE_SUBTRACT, &&TARGET_INPLACE_MULTIPLY, @@ -68,11 +68,11 @@ static void *opcode_targets[256] = { &&TARGET_BINARY_OR, &&TARGET_INPLACE_POWER, &&TARGET_GET_ITER, - &&_unknown_opcode, + &&TARGET_GET_YIELD_FROM_ITER, &&TARGET_PRINT_EXPR, &&TARGET_LOAD_BUILD_CLASS, &&TARGET_YIELD_FROM, - &&_unknown_opcode, + &&TARGET_GET_AWAITABLE, &&_unknown_opcode, &&TARGET_INPLACE_LSHIFT, &&TARGET_INPLACE_RSHIFT, @@ -80,8 +80,8 @@ static void *opcode_targets[256] = { &&TARGET_INPLACE_XOR, &&TARGET_INPLACE_OR, &&TARGET_BREAK_LOOP, - &&TARGET_WITH_CLEANUP, - &&_unknown_opcode, + &&TARGET_WITH_CLEANUP_START, + &&TARGET_WITH_CLEANUP_FINISH, &&TARGET_RETURN_VALUE, &&TARGET_IMPORT_STAR, &&_unknown_opcode, @@ -148,12 +148,12 @@ static void *opcode_targets[256] = { &&TARGET_SET_ADD, &&TARGET_MAP_ADD, &&TARGET_LOAD_CLASSDEREF, - &&_unknown_opcode, - &&_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, + &&TARGET_SETUP_ASYNC_WITH, &&_unknown_opcode, &&_unknown_opcode, &&_unknown_opcode, diff --git a/Python/peephole.c b/Python/peephole.c index c56c8fcc23..59ad3b762f 100644 --- a/Python/peephole.c +++ b/Python/peephole.c @@ -18,7 +18,11 @@ || op==JUMP_IF_FALSE_OR_POP || op==JUMP_IF_TRUE_OR_POP) #define JUMPS_ON_TRUE(op) (op==POP_JUMP_IF_TRUE || op==JUMP_IF_TRUE_OR_POP) #define GETJUMPTGT(arr, i) (GETARG(arr,i) + (ABSOLUTE_JUMP(arr[i]) ? 0 : i+3)) -#define SETARG(arr, i, val) arr[i+2] = val>>8; arr[i+1] = val & 255 +#define SETARG(arr, i, val) do { \ + assert(0 <= val && val <= 0xffff); \ + arr[i+2] = (unsigned char)(((unsigned int)val)>>8); \ + arr[i+1] = (unsigned char)(((unsigned int)val) & 255); \ +} while(0) #define CODESIZE(op) (HAS_ARG(op) ? 3 : 1) #define ISBASICBLOCK(blocks, start, bytes) \ (blocks[start]==blocks[start+bytes-1]) @@ -315,6 +319,7 @@ markblocks(unsigned char *code, Py_ssize_t len) case SETUP_EXCEPT: case SETUP_FINALLY: case SETUP_WITH: + case SETUP_ASYNC_WITH: j = GETJUMPTGT(code, i); blocks[j] = 1; break; @@ -355,7 +360,8 @@ PyCode_Optimize(PyObject *code, PyObject* consts, PyObject *names, unsigned char *codestr = NULL; unsigned char *lineno; int *addrmap = NULL; - int new_line, cum_orig_line, last_line, tabsiz; + int new_line, cum_orig_line, last_line; + Py_ssize_t tabsiz; PyObject **const_stack = NULL; Py_ssize_t *load_const_stack = NULL; Py_ssize_t const_stack_top = -1; @@ -615,6 +621,7 @@ PyCode_Optimize(PyObject *code, PyObject* consts, PyObject *names, case SETUP_EXCEPT: case SETUP_FINALLY: case SETUP_WITH: + case SETUP_ASYNC_WITH: tgt = GETJUMPTGT(codestr, i); /* Replace JUMP_* to a RETURN into just a RETURN */ if (UNCONDITIONAL_JUMP(opcode) && @@ -660,7 +667,8 @@ PyCode_Optimize(PyObject *code, PyObject* consts, PyObject *names, /* Fixup linenotab */ for (i=0, nops=0 ; i<codelen ; i += CODESIZE(codestr[i])) { - addrmap[i] = i - nops; + assert(i - nops <= INT_MAX); + addrmap[i] = (int)(i - nops); if (codestr[i] == NOP) nops++; } @@ -698,6 +706,7 @@ PyCode_Optimize(PyObject *code, PyObject* consts, PyObject *names, case SETUP_EXCEPT: case SETUP_FINALLY: case SETUP_WITH: + case SETUP_ASYNC_WITH: j = addrmap[GETARG(codestr, i) + i + 3] - addrmap[i] - 3; SETARG(codestr, i, j); break; diff --git a/Python/pyfpe.c b/Python/pyfpe.c index 4b7f5bae15..ab0ef83ead 100644 --- a/Python/pyfpe.c +++ b/Python/pyfpe.c @@ -1,6 +1,6 @@ #include "pyconfig.h" #include "pyfpe.h" -/* +/* * The signal handler for SIGFPE is actually declared in an external * module fpectl, or as preferred by the user. These variable * definitions are required in order to compile Python without @@ -13,7 +13,7 @@ jmp_buf PyFPE_jbuf; int PyFPE_counter = 0; #endif -/* Have this outside the above #ifdef, since some picky ANSI compilers issue a +/* Have this outside the above #ifdef, since some picky ANSI compilers issue a warning when compiling an empty file. */ double diff --git a/Python/pylifecycle.c b/Python/pylifecycle.c new file mode 100644 index 0000000000..4f5efc963c --- /dev/null +++ b/Python/pylifecycle.c @@ -0,0 +1,1582 @@ +/* Python interpreter top-level routines, including init/exit */ + +#include "Python.h" + +#include "Python-ast.h" +#undef Yield /* undefine macro conflicting with winbase.h */ +#include "grammar.h" +#include "node.h" +#include "token.h" +#include "parsetok.h" +#include "errcode.h" +#include "code.h" +#include "symtable.h" +#include "ast.h" +#include "marshal.h" +#include "osdefs.h" +#include <locale.h> + +#ifdef HAVE_SIGNAL_H +#include <signal.h> +#endif + +#ifdef MS_WINDOWS +#include "malloc.h" /* for alloca */ +#endif + +#ifdef HAVE_LANGINFO_H +#include <langinfo.h> +#endif + +#ifdef MS_WINDOWS +#undef BYTE +#include "windows.h" +#endif + +_Py_IDENTIFIER(flush); +_Py_IDENTIFIER(name); +_Py_IDENTIFIER(stdin); +_Py_IDENTIFIER(stdout); +_Py_IDENTIFIER(stderr); + +#ifdef __cplusplus +extern "C" { +#endif + +extern wchar_t *Py_GetPath(void); + +extern grammar _PyParser_Grammar; /* From graminit.c */ + +/* Forward */ +static void initmain(PyInterpreterState *interp); +static int initfsencoding(PyInterpreterState *interp); +static void initsite(void); +static int initstdio(void); +static void initsigs(void); +static void call_py_exitfuncs(void); +static void wait_for_thread_shutdown(void); +static void call_ll_exitfuncs(void); +extern int _PyUnicode_Init(void); +extern int _PyStructSequence_Init(void); +extern void _PyUnicode_Fini(void); +extern int _PyLong_Init(void); +extern void PyLong_Fini(void); +extern int _PyFaulthandler_Init(void); +extern void _PyFaulthandler_Fini(void); +extern void _PyHash_Fini(void); +extern int _PyTraceMalloc_Init(void); +extern int _PyTraceMalloc_Fini(void); + +#ifdef WITH_THREAD +extern void _PyGILState_Init(PyInterpreterState *, PyThreadState *); +extern void _PyGILState_Fini(void); +#endif /* WITH_THREAD */ + +/* Global configuration variable declarations are in pydebug.h */ +/* XXX (ncoghlan): move those declarations to pylifecycle.h? */ +int Py_DebugFlag; /* Needed by parser.c */ +int Py_VerboseFlag; /* Needed by import.c */ +int Py_QuietFlag; /* Needed by sysmodule.c */ +int Py_InteractiveFlag; /* Needed by Py_FdIsInteractive() below */ +int Py_InspectFlag; /* Needed to determine whether to exit at SystemExit */ +int Py_OptimizeFlag = 0; /* Needed by compile.c */ +int Py_NoSiteFlag; /* Suppress 'import site' */ +int Py_BytesWarningFlag; /* Warn on str(bytes) and str(buffer) */ +int Py_UseClassExceptionsFlag = 1; /* Needed by bltinmodule.c: deprecated */ +int Py_FrozenFlag; /* Needed by getpath.c */ +int Py_IgnoreEnvironmentFlag; /* e.g. PYTHONPATH, PYTHONHOME */ +int Py_DontWriteBytecodeFlag; /* Suppress writing bytecode files (*.py[co]) */ +int Py_NoUserSiteDirectory = 0; /* for -s and site.py */ +int Py_UnbufferedStdioFlag = 0; /* Unbuffered binary std{in,out,err} */ +int Py_HashRandomizationFlag = 0; /* for -R and PYTHONHASHSEED */ +int Py_IsolatedFlag = 0; /* for -I, isolate from user's env */ + +PyThreadState *_Py_Finalizing = NULL; + +/* Hack to force loading of object files */ +int (*_PyOS_mystrnicmp_hack)(const char *, const char *, Py_ssize_t) = \ + PyOS_mystrnicmp; /* Python/pystrcmp.o */ + +/* PyModule_GetWarningsModule is no longer necessary as of 2.6 +since _warnings is builtin. This API should not be used. */ +PyObject * +PyModule_GetWarningsModule(void) +{ + return PyImport_ImportModule("warnings"); +} + +static int initialized = 0; + +/* API to access the initialized flag -- useful for esoteric use */ + +int +Py_IsInitialized(void) +{ + return initialized; +} + +/* Helper to allow an embedding application to override the normal + * mechanism that attempts to figure out an appropriate IO encoding + */ + +static char *_Py_StandardStreamEncoding = NULL; +static char *_Py_StandardStreamErrors = NULL; + +int +Py_SetStandardStreamEncoding(const char *encoding, const char *errors) +{ + if (Py_IsInitialized()) { + /* This is too late to have any effect */ + return -1; + } + /* Can't call PyErr_NoMemory() on errors, as Python hasn't been + * initialised yet. + * + * However, the raw memory allocators are initialised appropriately + * as C static variables, so _PyMem_RawStrdup is OK even though + * Py_Initialize hasn't been called yet. + */ + if (encoding) { + _Py_StandardStreamEncoding = _PyMem_RawStrdup(encoding); + if (!_Py_StandardStreamEncoding) { + return -2; + } + } + if (errors) { + _Py_StandardStreamErrors = _PyMem_RawStrdup(errors); + if (!_Py_StandardStreamErrors) { + if (_Py_StandardStreamEncoding) { + PyMem_RawFree(_Py_StandardStreamEncoding); + } + return -3; + } + } + return 0; +} + +/* Global initializations. Can be undone by Py_Finalize(). Don't + call this twice without an intervening Py_Finalize() call. When + initializations fail, a fatal error is issued and the function does + not return. On return, the first thread and interpreter state have + been created. + + Locking: you must hold the interpreter lock while calling this. + (If the lock has not yet been initialized, that's equivalent to + having the lock, but you cannot use multiple threads.) + +*/ + +static int +add_flag(int flag, const char *envs) +{ + int env = atoi(envs); + if (flag < env) + flag = env; + if (flag < 1) + flag = 1; + return flag; +} + +static char* +get_codec_name(const char *encoding) +{ + char *name_utf8, *name_str; + PyObject *codec, *name = NULL; + + codec = _PyCodec_Lookup(encoding); + if (!codec) + goto error; + + name = _PyObject_GetAttrId(codec, &PyId_name); + Py_CLEAR(codec); + if (!name) + goto error; + + name_utf8 = _PyUnicode_AsString(name); + if (name_utf8 == NULL) + goto error; + name_str = _PyMem_RawStrdup(name_utf8); + Py_DECREF(name); + if (name_str == NULL) { + PyErr_NoMemory(); + return NULL; + } + return name_str; + +error: + Py_XDECREF(codec); + Py_XDECREF(name); + return NULL; +} + +static char* +get_locale_encoding(void) +{ +#ifdef MS_WINDOWS + char codepage[100]; + PyOS_snprintf(codepage, sizeof(codepage), "cp%d", GetACP()); + return get_codec_name(codepage); +#elif defined(HAVE_LANGINFO_H) && defined(CODESET) + char* codeset = nl_langinfo(CODESET); + if (!codeset || codeset[0] == '\0') { + PyErr_SetString(PyExc_ValueError, "CODESET is not set or empty"); + return NULL; + } + return get_codec_name(codeset); +#else + PyErr_SetNone(PyExc_NotImplementedError); + return NULL; +#endif +} + +static void +import_init(PyInterpreterState *interp, PyObject *sysmod) +{ + PyObject *importlib; + PyObject *impmod; + PyObject *sys_modules; + PyObject *value; + + /* Import _importlib through its frozen version, _frozen_importlib. */ + if (PyImport_ImportFrozenModule("_frozen_importlib") <= 0) { + Py_FatalError("Py_Initialize: can't import _frozen_importlib"); + } + else if (Py_VerboseFlag) { + PySys_FormatStderr("import _frozen_importlib # frozen\n"); + } + importlib = PyImport_AddModule("_frozen_importlib"); + if (importlib == NULL) { + Py_FatalError("Py_Initialize: couldn't get _frozen_importlib from " + "sys.modules"); + } + interp->importlib = importlib; + Py_INCREF(interp->importlib); + + /* Import the _imp module */ + impmod = PyInit_imp(); + if (impmod == NULL) { + Py_FatalError("Py_Initialize: can't import _imp"); + } + else if (Py_VerboseFlag) { + PySys_FormatStderr("import _imp # builtin\n"); + } + sys_modules = PyImport_GetModuleDict(); + if (Py_VerboseFlag) { + PySys_FormatStderr("import sys # builtin\n"); + } + if (PyDict_SetItemString(sys_modules, "_imp", impmod) < 0) { + Py_FatalError("Py_Initialize: can't save _imp to sys.modules"); + } + + /* Install importlib as the implementation of import */ + value = PyObject_CallMethod(importlib, "_install", "OO", sysmod, impmod); + if (value == NULL) { + PyErr_Print(); + Py_FatalError("Py_Initialize: importlib install failed"); + } + Py_DECREF(value); + Py_DECREF(impmod); + + _PyImportZip_Init(); +} + + +void +_Py_InitializeEx_Private(int install_sigs, int install_importlib) +{ + PyInterpreterState *interp; + PyThreadState *tstate; + PyObject *bimod, *sysmod, *pstderr; + char *p; + extern void _Py_ReadyTypes(void); + + if (initialized) + return; + initialized = 1; + _Py_Finalizing = NULL; + +#if defined(HAVE_LANGINFO_H) && defined(HAVE_SETLOCALE) + /* Set up the LC_CTYPE locale, so we can obtain + the locale's charset without having to switch + locales. */ + setlocale(LC_CTYPE, ""); +#endif + + if ((p = Py_GETENV("PYTHONDEBUG")) && *p != '\0') + Py_DebugFlag = add_flag(Py_DebugFlag, p); + if ((p = Py_GETENV("PYTHONVERBOSE")) && *p != '\0') + Py_VerboseFlag = add_flag(Py_VerboseFlag, p); + if ((p = Py_GETENV("PYTHONOPTIMIZE")) && *p != '\0') + Py_OptimizeFlag = add_flag(Py_OptimizeFlag, p); + if ((p = Py_GETENV("PYTHONDONTWRITEBYTECODE")) && *p != '\0') + Py_DontWriteBytecodeFlag = add_flag(Py_DontWriteBytecodeFlag, p); + /* The variable is only tested for existence here; _PyRandom_Init will + check its value further. */ + if ((p = Py_GETENV("PYTHONHASHSEED")) && *p != '\0') + Py_HashRandomizationFlag = add_flag(Py_HashRandomizationFlag, p); + + _PyRandom_Init(); + + interp = PyInterpreterState_New(); + if (interp == NULL) + Py_FatalError("Py_Initialize: can't make first interpreter"); + + tstate = PyThreadState_New(interp); + if (tstate == NULL) + Py_FatalError("Py_Initialize: can't make first thread"); + (void) PyThreadState_Swap(tstate); + +#ifdef WITH_THREAD + /* We can't call _PyEval_FiniThreads() in Py_Finalize because + destroying the GIL might fail when it is being referenced from + another running thread (see issue #9901). + Instead we destroy the previously created GIL here, which ensures + that we can call Py_Initialize / Py_Finalize multiple times. */ + _PyEval_FiniThreads(); + + /* Auto-thread-state API */ + _PyGILState_Init(interp, tstate); +#endif /* WITH_THREAD */ + + _Py_ReadyTypes(); + + if (!_PyFrame_Init()) + Py_FatalError("Py_Initialize: can't init frames"); + + if (!_PyLong_Init()) + Py_FatalError("Py_Initialize: can't init longs"); + + if (!PyByteArray_Init()) + Py_FatalError("Py_Initialize: can't init bytearray"); + + if (!_PyFloat_Init()) + Py_FatalError("Py_Initialize: can't init float"); + + interp->modules = PyDict_New(); + if (interp->modules == NULL) + Py_FatalError("Py_Initialize: can't make modules dictionary"); + + /* Init Unicode implementation; relies on the codec registry */ + if (_PyUnicode_Init() < 0) + Py_FatalError("Py_Initialize: can't initialize unicode"); + if (_PyStructSequence_Init() < 0) + Py_FatalError("Py_Initialize: can't initialize structseq"); + + bimod = _PyBuiltin_Init(); + if (bimod == NULL) + Py_FatalError("Py_Initialize: can't initialize builtins modules"); + _PyImport_FixupBuiltin(bimod, "builtins"); + interp->builtins = PyModule_GetDict(bimod); + if (interp->builtins == NULL) + Py_FatalError("Py_Initialize: can't initialize builtins dict"); + Py_INCREF(interp->builtins); + + /* initialize builtin exceptions */ + _PyExc_Init(bimod); + + sysmod = _PySys_Init(); + if (sysmod == NULL) + Py_FatalError("Py_Initialize: can't initialize sys"); + interp->sysdict = PyModule_GetDict(sysmod); + if (interp->sysdict == NULL) + Py_FatalError("Py_Initialize: can't initialize sys dict"); + Py_INCREF(interp->sysdict); + _PyImport_FixupBuiltin(sysmod, "sys"); + PySys_SetPath(Py_GetPath()); + PyDict_SetItemString(interp->sysdict, "modules", + interp->modules); + + /* Set up a preliminary stderr printer until we have enough + infrastructure for the io module in place. */ + pstderr = PyFile_NewStdPrinter(fileno(stderr)); + if (pstderr == NULL) + Py_FatalError("Py_Initialize: can't set preliminary stderr"); + _PySys_SetObjectId(&PyId_stderr, pstderr); + PySys_SetObject("__stderr__", pstderr); + Py_DECREF(pstderr); + + _PyImport_Init(); + + _PyImportHooks_Init(); + + /* Initialize _warnings. */ + _PyWarnings_Init(); + + if (!install_importlib) + return; + + if (_PyTime_Init() < 0) + Py_FatalError("Py_Initialize: can't initialize time"); + + import_init(interp, sysmod); + + /* initialize the faulthandler module */ + if (_PyFaulthandler_Init()) + Py_FatalError("Py_Initialize: can't initialize faulthandler"); + + if (initfsencoding(interp) < 0) + Py_FatalError("Py_Initialize: unable to load the file system codec"); + + if (install_sigs) + initsigs(); /* Signal handling stuff, including initintr() */ + + if (_PyTraceMalloc_Init() < 0) + Py_FatalError("Py_Initialize: can't initialize tracemalloc"); + + initmain(interp); /* Module __main__ */ + if (initstdio() < 0) + Py_FatalError( + "Py_Initialize: can't initialize sys standard streams"); + + /* Initialize warnings. */ + if (PySys_HasWarnOptions()) { + PyObject *warnings_module = PyImport_ImportModule("warnings"); + if (warnings_module == NULL) { + fprintf(stderr, "'import warnings' failed; traceback:\n"); + PyErr_Print(); + } + Py_XDECREF(warnings_module); + } + + if (!Py_NoSiteFlag) + initsite(); /* Module site */ +} + +void +Py_InitializeEx(int install_sigs) +{ + _Py_InitializeEx_Private(install_sigs, 1); +} + +void +Py_Initialize(void) +{ + Py_InitializeEx(1); +} + + +#ifdef COUNT_ALLOCS +extern void dump_counts(FILE*); +#endif + +/* Flush stdout and stderr */ + +static int +file_is_closed(PyObject *fobj) +{ + int r; + PyObject *tmp = PyObject_GetAttrString(fobj, "closed"); + if (tmp == NULL) { + PyErr_Clear(); + return 0; + } + r = PyObject_IsTrue(tmp); + Py_DECREF(tmp); + if (r < 0) + PyErr_Clear(); + return r > 0; +} + +static void +flush_std_files(void) +{ + PyObject *fout = _PySys_GetObjectId(&PyId_stdout); + PyObject *ferr = _PySys_GetObjectId(&PyId_stderr); + PyObject *tmp; + + if (fout != NULL && fout != Py_None && !file_is_closed(fout)) { + tmp = _PyObject_CallMethodId(fout, &PyId_flush, ""); + if (tmp == NULL) + PyErr_WriteUnraisable(fout); + else + Py_DECREF(tmp); + } + + if (ferr != NULL && ferr != Py_None && !file_is_closed(ferr)) { + tmp = _PyObject_CallMethodId(ferr, &PyId_flush, ""); + if (tmp == NULL) + PyErr_Clear(); + else + Py_DECREF(tmp); + } +} + +/* Undo the effect of Py_Initialize(). + + Beware: if multiple interpreter and/or thread states exist, these + are not wiped out; only the current thread and interpreter state + are deleted. But since everything else is deleted, those other + interpreter and thread states should no longer be used. + + (XXX We should do better, e.g. wipe out all interpreters and + threads.) + + Locking: as above. + +*/ + +void +Py_Finalize(void) +{ + PyInterpreterState *interp; + PyThreadState *tstate; + + if (!initialized) + return; + + wait_for_thread_shutdown(); + + /* The interpreter is still entirely intact at this point, and the + * exit funcs may be relying on that. In particular, if some thread + * or exit func is still waiting to do an import, the import machinery + * expects Py_IsInitialized() to return true. So don't say the + * interpreter is uninitialized until after the exit funcs have run. + * Note that Threading.py uses an exit func to do a join on all the + * threads created thru it, so this also protects pending imports in + * the threads created via Threading. + */ + call_py_exitfuncs(); + + /* Get current thread state and interpreter pointer */ + tstate = PyThreadState_GET(); + interp = tstate->interp; + + /* Remaining threads (e.g. daemon threads) will automatically exit + after taking the GIL (in PyEval_RestoreThread()). */ + _Py_Finalizing = tstate; + initialized = 0; + + /* Flush sys.stdout and sys.stderr */ + flush_std_files(); + + /* Disable signal handling */ + PyOS_FiniInterrupts(); + + /* Collect garbage. This may call finalizers; it's nice to call these + * before all modules are destroyed. + * XXX If a __del__ or weakref callback is triggered here, and tries to + * XXX import a module, bad things can happen, because Python no + * XXX longer believes it's initialized. + * XXX Fatal Python error: Interpreter not initialized (version mismatch?) + * XXX is easy to provoke that way. I've also seen, e.g., + * XXX Exception exceptions.ImportError: 'No module named sha' + * XXX in <function callback at 0x008F5718> ignored + * XXX but I'm unclear on exactly how that one happens. In any case, + * XXX I haven't seen a real-life report of either of these. + */ + PyGC_Collect(); +#ifdef COUNT_ALLOCS + /* With COUNT_ALLOCS, it helps to run GC multiple times: + each collection might release some types from the type + list, so they become garbage. */ + while (PyGC_Collect() > 0) + /* nothing */; +#endif + /* Destroy all modules */ + PyImport_Cleanup(); + + /* Flush sys.stdout and sys.stderr (again, in case more was printed) */ + flush_std_files(); + + /* Collect final garbage. This disposes of cycles created by + * class definitions, for example. + * XXX This is disabled because it caused too many problems. If + * XXX a __del__ or weakref callback triggers here, Python code has + * XXX a hard time running, because even the sys module has been + * XXX cleared out (sys.stdout is gone, sys.excepthook is gone, etc). + * XXX One symptom is a sequence of information-free messages + * XXX coming from threads (if a __del__ or callback is invoked, + * XXX other threads can execute too, and any exception they encounter + * XXX triggers a comedy of errors as subsystem after subsystem + * XXX fails to find what it *expects* to find in sys to help report + * XXX the exception and consequent unexpected failures). I've also + * XXX seen segfaults then, after adding print statements to the + * XXX Python code getting called. + */ +#if 0 + PyGC_Collect(); +#endif + + /* Disable tracemalloc after all Python objects have been destroyed, + so it is possible to use tracemalloc in objects destructor. */ + _PyTraceMalloc_Fini(); + + /* Destroy the database used by _PyImport_{Fixup,Find}Extension */ + _PyImport_Fini(); + + /* Cleanup typeobject.c's internal caches. */ + _PyType_Fini(); + + /* unload faulthandler module */ + _PyFaulthandler_Fini(); + + /* Debugging stuff */ +#ifdef COUNT_ALLOCS + dump_counts(stdout); +#endif + /* dump hash stats */ + _PyHash_Fini(); + + _PY_DEBUG_PRINT_TOTAL_REFS(); + +#ifdef Py_TRACE_REFS + /* Display all objects still alive -- this can invoke arbitrary + * __repr__ overrides, so requires a mostly-intact interpreter. + * Alas, a lot of stuff may still be alive now that will be cleaned + * up later. + */ + if (Py_GETENV("PYTHONDUMPREFS")) + _Py_PrintReferences(stderr); +#endif /* Py_TRACE_REFS */ + + /* Clear interpreter state and all thread states. */ + PyInterpreterState_Clear(interp); + + /* Now we decref the exception classes. After this point nothing + can raise an exception. That's okay, because each Fini() method + below has been checked to make sure no exceptions are ever + raised. + */ + + _PyExc_Fini(); + + /* Sundry finalizers */ + PyMethod_Fini(); + PyFrame_Fini(); + PyCFunction_Fini(); + PyTuple_Fini(); + PyList_Fini(); + PySet_Fini(); + PyBytes_Fini(); + PyByteArray_Fini(); + PyLong_Fini(); + PyFloat_Fini(); + PyDict_Fini(); + PySlice_Fini(); + _PyGC_Fini(); + _PyRandom_Fini(); + + /* Cleanup Unicode implementation */ + _PyUnicode_Fini(); + + /* reset file system default encoding */ + if (!Py_HasFileSystemDefaultEncoding && Py_FileSystemDefaultEncoding) { + PyMem_RawFree((char*)Py_FileSystemDefaultEncoding); + Py_FileSystemDefaultEncoding = NULL; + } + + /* XXX Still allocated: + - various static ad-hoc pointers to interned strings + - int and float free list blocks + - whatever various modules and libraries allocate + */ + + PyGrammar_RemoveAccelerators(&_PyParser_Grammar); + + /* Cleanup auto-thread-state */ +#ifdef WITH_THREAD + _PyGILState_Fini(); +#endif /* WITH_THREAD */ + + /* Delete current thread. After this, many C API calls become crashy. */ + PyThreadState_Swap(NULL); + PyInterpreterState_Delete(interp); + +#ifdef Py_TRACE_REFS + /* Display addresses (& refcnts) of all objects still alive. + * An address can be used to find the repr of the object, printed + * above by _Py_PrintReferences. + */ + if (Py_GETENV("PYTHONDUMPREFS")) + _Py_PrintReferenceAddresses(stderr); +#endif /* Py_TRACE_REFS */ +#ifdef PYMALLOC_DEBUG + if (Py_GETENV("PYTHONMALLOCSTATS")) + _PyObject_DebugMallocStats(stderr); +#endif + + call_ll_exitfuncs(); +} + +/* Create and initialize a new interpreter and thread, and return the + new thread. This requires that Py_Initialize() has been called + first. + + Unsuccessful initialization yields a NULL pointer. Note that *no* + exception information is available even in this case -- the + exception information is held in the thread, and there is no + thread. + + Locking: as above. + +*/ + +PyThreadState * +Py_NewInterpreter(void) +{ + PyInterpreterState *interp; + PyThreadState *tstate, *save_tstate; + PyObject *bimod, *sysmod; + + if (!initialized) + Py_FatalError("Py_NewInterpreter: call Py_Initialize first"); + + interp = PyInterpreterState_New(); + if (interp == NULL) + return NULL; + + tstate = PyThreadState_New(interp); + if (tstate == NULL) { + PyInterpreterState_Delete(interp); + return NULL; + } + + save_tstate = PyThreadState_Swap(tstate); + + /* XXX The following is lax in error checking */ + + interp->modules = PyDict_New(); + + bimod = _PyImport_FindBuiltin("builtins"); + if (bimod != NULL) { + interp->builtins = PyModule_GetDict(bimod); + if (interp->builtins == NULL) + goto handle_error; + Py_INCREF(interp->builtins); + } + + /* initialize builtin exceptions */ + _PyExc_Init(bimod); + + sysmod = _PyImport_FindBuiltin("sys"); + if (bimod != NULL && sysmod != NULL) { + PyObject *pstderr; + + interp->sysdict = PyModule_GetDict(sysmod); + if (interp->sysdict == NULL) + goto handle_error; + Py_INCREF(interp->sysdict); + PySys_SetPath(Py_GetPath()); + PyDict_SetItemString(interp->sysdict, "modules", + interp->modules); + /* Set up a preliminary stderr printer until we have enough + infrastructure for the io module in place. */ + pstderr = PyFile_NewStdPrinter(fileno(stderr)); + if (pstderr == NULL) + Py_FatalError("Py_Initialize: can't set preliminary stderr"); + _PySys_SetObjectId(&PyId_stderr, pstderr); + PySys_SetObject("__stderr__", pstderr); + Py_DECREF(pstderr); + + _PyImportHooks_Init(); + + import_init(interp, sysmod); + + if (initfsencoding(interp) < 0) + goto handle_error; + + if (initstdio() < 0) + Py_FatalError( + "Py_Initialize: can't initialize sys standard streams"); + initmain(interp); + if (!Py_NoSiteFlag) + initsite(); + } + + if (!PyErr_Occurred()) + return tstate; + +handle_error: + /* Oops, it didn't work. Undo it all. */ + + PyErr_PrintEx(0); + PyThreadState_Clear(tstate); + PyThreadState_Swap(save_tstate); + PyThreadState_Delete(tstate); + PyInterpreterState_Delete(interp); + + return NULL; +} + +/* Delete an interpreter and its last thread. This requires that the + given thread state is current, that the thread has no remaining + frames, and that it is its interpreter's only remaining thread. + It is a fatal error to violate these constraints. + + (Py_Finalize() doesn't have these constraints -- it zaps + everything, regardless.) + + Locking: as above. + +*/ + +void +Py_EndInterpreter(PyThreadState *tstate) +{ + PyInterpreterState *interp = tstate->interp; + + if (tstate != PyThreadState_GET()) + Py_FatalError("Py_EndInterpreter: thread is not current"); + if (tstate->frame != NULL) + Py_FatalError("Py_EndInterpreter: thread still has a frame"); + + wait_for_thread_shutdown(); + + if (tstate != interp->tstate_head || tstate->next != NULL) + Py_FatalError("Py_EndInterpreter: not the last thread"); + + PyImport_Cleanup(); + PyInterpreterState_Clear(interp); + PyThreadState_Swap(NULL); + PyInterpreterState_Delete(interp); +} + +#ifdef MS_WINDOWS +static wchar_t *progname = L"python"; +#else +static wchar_t *progname = L"python3"; +#endif + +void +Py_SetProgramName(wchar_t *pn) +{ + if (pn && *pn) + progname = pn; +} + +wchar_t * +Py_GetProgramName(void) +{ + return progname; +} + +static wchar_t *default_home = NULL; +static wchar_t env_home[MAXPATHLEN+1]; + +void +Py_SetPythonHome(wchar_t *home) +{ + default_home = home; +} + +wchar_t * +Py_GetPythonHome(void) +{ + wchar_t *home = default_home; + if (home == NULL && !Py_IgnoreEnvironmentFlag) { + char* chome = Py_GETENV("PYTHONHOME"); + if (chome) { + size_t size = Py_ARRAY_LENGTH(env_home); + size_t r = mbstowcs(env_home, chome, size); + if (r != (size_t)-1 && r < size) + home = env_home; + } + + } + return home; +} + +/* Create __main__ module */ + +static void +initmain(PyInterpreterState *interp) +{ + PyObject *m, *d, *loader; + m = PyImport_AddModule("__main__"); + if (m == NULL) + Py_FatalError("can't create __main__ module"); + d = PyModule_GetDict(m); + if (PyDict_GetItemString(d, "__builtins__") == NULL) { + PyObject *bimod = PyImport_ImportModule("builtins"); + if (bimod == NULL) { + Py_FatalError("Failed to retrieve builtins module"); + } + if (PyDict_SetItemString(d, "__builtins__", bimod) < 0) { + Py_FatalError("Failed to initialize __main__.__builtins__"); + } + Py_DECREF(bimod); + } + /* Main is a little special - imp.is_builtin("__main__") will return + * False, but BuiltinImporter is still the most appropriate initial + * setting for its __loader__ attribute. A more suitable value will + * be set if __main__ gets further initialized later in the startup + * process. + */ + loader = PyDict_GetItemString(d, "__loader__"); + if (loader == NULL || loader == Py_None) { + PyObject *loader = PyObject_GetAttrString(interp->importlib, + "BuiltinImporter"); + if (loader == NULL) { + Py_FatalError("Failed to retrieve BuiltinImporter"); + } + if (PyDict_SetItemString(d, "__loader__", loader) < 0) { + Py_FatalError("Failed to initialize __main__.__loader__"); + } + Py_DECREF(loader); + } +} + +static int +initfsencoding(PyInterpreterState *interp) +{ + PyObject *codec; + + if (Py_FileSystemDefaultEncoding == NULL) + { + Py_FileSystemDefaultEncoding = get_locale_encoding(); + if (Py_FileSystemDefaultEncoding == NULL) + Py_FatalError("Py_Initialize: Unable to get the locale encoding"); + + Py_HasFileSystemDefaultEncoding = 0; + interp->fscodec_initialized = 1; + return 0; + } + + /* the encoding is mbcs, utf-8 or ascii */ + codec = _PyCodec_Lookup(Py_FileSystemDefaultEncoding); + if (!codec) { + /* Such error can only occurs in critical situations: no more + * memory, import a module of the standard library failed, + * etc. */ + return -1; + } + Py_DECREF(codec); + interp->fscodec_initialized = 1; + return 0; +} + +/* Import the site module (not into __main__ though) */ + +static void +initsite(void) +{ + PyObject *m; + m = PyImport_ImportModule("site"); + if (m == NULL) { + fprintf(stderr, "Failed to import the site module\n"); + PyErr_Print(); + Py_Finalize(); + exit(1); + } + else { + Py_DECREF(m); + } +} + +/* Check if a file descriptor is valid or not. + Return 0 if the file descriptor is invalid, return non-zero otherwise. */ +static int +is_valid_fd(int fd) +{ + int fd2; + if (fd < 0 || !_PyVerify_fd(fd)) + return 0; + _Py_BEGIN_SUPPRESS_IPH + fd2 = dup(fd); + if (fd2 >= 0) + close(fd2); + _Py_END_SUPPRESS_IPH + return fd2 >= 0; +} + +/* returns Py_None if the fd is not valid */ +static PyObject* +create_stdio(PyObject* io, + int fd, int write_mode, char* name, + char* encoding, char* errors) +{ + PyObject *buf = NULL, *stream = NULL, *text = NULL, *raw = NULL, *res; + const char* mode; + const char* newline; + PyObject *line_buffering; + int buffering, isatty; + _Py_IDENTIFIER(open); + _Py_IDENTIFIER(isatty); + _Py_IDENTIFIER(TextIOWrapper); + _Py_IDENTIFIER(mode); + + if (!is_valid_fd(fd)) + Py_RETURN_NONE; + + /* stdin is always opened in buffered mode, first because it shouldn't + make a difference in common use cases, second because TextIOWrapper + depends on the presence of a read1() method which only exists on + buffered streams. + */ + if (Py_UnbufferedStdioFlag && write_mode) + buffering = 0; + else + buffering = -1; + if (write_mode) + mode = "wb"; + else + mode = "rb"; + buf = _PyObject_CallMethodId(io, &PyId_open, "isiOOOi", + fd, mode, buffering, + Py_None, Py_None, Py_None, 0); + if (buf == NULL) + goto error; + + if (buffering) { + _Py_IDENTIFIER(raw); + raw = _PyObject_GetAttrId(buf, &PyId_raw); + if (raw == NULL) + goto error; + } + else { + raw = buf; + Py_INCREF(raw); + } + + text = PyUnicode_FromString(name); + if (text == NULL || _PyObject_SetAttrId(raw, &PyId_name, text) < 0) + goto error; + res = _PyObject_CallMethodId(raw, &PyId_isatty, ""); + if (res == NULL) + goto error; + isatty = PyObject_IsTrue(res); + Py_DECREF(res); + if (isatty == -1) + goto error; + if (isatty || Py_UnbufferedStdioFlag) + line_buffering = Py_True; + else + line_buffering = Py_False; + + Py_CLEAR(raw); + Py_CLEAR(text); + +#ifdef MS_WINDOWS + /* sys.stdin: enable universal newline mode, translate "\r\n" and "\r" + newlines to "\n". + sys.stdout and sys.stderr: translate "\n" to "\r\n". */ + newline = NULL; +#else + /* sys.stdin: split lines at "\n". + sys.stdout and sys.stderr: don't translate newlines (use "\n"). */ + newline = "\n"; +#endif + + stream = _PyObject_CallMethodId(io, &PyId_TextIOWrapper, "OsssO", + buf, encoding, errors, + newline, line_buffering); + Py_CLEAR(buf); + if (stream == NULL) + goto error; + + if (write_mode) + mode = "w"; + else + mode = "r"; + text = PyUnicode_FromString(mode); + if (!text || _PyObject_SetAttrId(stream, &PyId_mode, text) < 0) + goto error; + Py_CLEAR(text); + return stream; + +error: + Py_XDECREF(buf); + Py_XDECREF(stream); + Py_XDECREF(text); + Py_XDECREF(raw); + + if (PyErr_ExceptionMatches(PyExc_OSError) && !is_valid_fd(fd)) { + /* Issue #24891: the file descriptor was closed after the first + is_valid_fd() check was called. Ignore the OSError and set the + stream to None. */ + PyErr_Clear(); + Py_RETURN_NONE; + } + return NULL; +} + +/* Initialize sys.stdin, stdout, stderr and builtins.open */ +static int +initstdio(void) +{ + PyObject *iomod = NULL, *wrapper; + PyObject *bimod = NULL; + PyObject *m; + PyObject *std = NULL; + int status = 0, fd; + PyObject * encoding_attr; + char *pythonioencoding = NULL, *encoding, *errors; + + /* Hack to avoid a nasty recursion issue when Python is invoked + in verbose mode: pre-import the Latin-1 and UTF-8 codecs */ + if ((m = PyImport_ImportModule("encodings.utf_8")) == NULL) { + goto error; + } + Py_DECREF(m); + + if (!(m = PyImport_ImportModule("encodings.latin_1"))) { + goto error; + } + Py_DECREF(m); + + if (!(bimod = PyImport_ImportModule("builtins"))) { + goto error; + } + + if (!(iomod = PyImport_ImportModule("io"))) { + goto error; + } + if (!(wrapper = PyObject_GetAttrString(iomod, "OpenWrapper"))) { + goto error; + } + + /* Set builtins.open */ + if (PyObject_SetAttrString(bimod, "open", wrapper) == -1) { + Py_DECREF(wrapper); + goto error; + } + Py_DECREF(wrapper); + + encoding = _Py_StandardStreamEncoding; + errors = _Py_StandardStreamErrors; + if (!encoding || !errors) { + if (!errors) { + /* When the LC_CTYPE locale is the POSIX locale ("C locale"), + stdin and stdout use the surrogateescape error handler by + default, instead of the strict error handler. */ + char *loc = setlocale(LC_CTYPE, NULL); + if (loc != NULL && strcmp(loc, "C") == 0) + errors = "surrogateescape"; + } + + pythonioencoding = Py_GETENV("PYTHONIOENCODING"); + if (pythonioencoding) { + char *err; + pythonioencoding = _PyMem_Strdup(pythonioencoding); + if (pythonioencoding == NULL) { + PyErr_NoMemory(); + goto error; + } + err = strchr(pythonioencoding, ':'); + if (err) { + *err = '\0'; + err++; + if (*err && !_Py_StandardStreamErrors) { + errors = err; + } + } + if (*pythonioencoding && !encoding) { + encoding = pythonioencoding; + } + } + } + + /* Set sys.stdin */ + fd = fileno(stdin); + /* Under some conditions stdin, stdout and stderr may not be connected + * and fileno() may point to an invalid file descriptor. For example + * GUI apps don't have valid standard streams by default. + */ + std = create_stdio(iomod, fd, 0, "<stdin>", encoding, errors); + if (std == NULL) + goto error; + PySys_SetObject("__stdin__", std); + _PySys_SetObjectId(&PyId_stdin, std); + Py_DECREF(std); + + /* Set sys.stdout */ + fd = fileno(stdout); + std = create_stdio(iomod, fd, 1, "<stdout>", encoding, errors); + if (std == NULL) + goto error; + PySys_SetObject("__stdout__", std); + _PySys_SetObjectId(&PyId_stdout, std); + Py_DECREF(std); + +#if 1 /* Disable this if you have trouble debugging bootstrap stuff */ + /* Set sys.stderr, replaces the preliminary stderr */ + fd = fileno(stderr); + std = create_stdio(iomod, fd, 1, "<stderr>", encoding, "backslashreplace"); + if (std == NULL) + goto error; + + /* Same as hack above, pre-import stderr's codec to avoid recursion + when import.c tries to write to stderr in verbose mode. */ + encoding_attr = PyObject_GetAttrString(std, "encoding"); + if (encoding_attr != NULL) { + const char * std_encoding; + std_encoding = _PyUnicode_AsString(encoding_attr); + if (std_encoding != NULL) { + PyObject *codec_info = _PyCodec_Lookup(std_encoding); + Py_XDECREF(codec_info); + } + Py_DECREF(encoding_attr); + } + PyErr_Clear(); /* Not a fatal error if codec isn't available */ + + if (PySys_SetObject("__stderr__", std) < 0) { + Py_DECREF(std); + goto error; + } + if (_PySys_SetObjectId(&PyId_stderr, std) < 0) { + Py_DECREF(std); + goto error; + } + Py_DECREF(std); +#endif + + if (0) { + error: + status = -1; + } + + /* We won't need them anymore. */ + if (_Py_StandardStreamEncoding) { + PyMem_RawFree(_Py_StandardStreamEncoding); + _Py_StandardStreamEncoding = NULL; + } + if (_Py_StandardStreamErrors) { + PyMem_RawFree(_Py_StandardStreamErrors); + _Py_StandardStreamErrors = NULL; + } + PyMem_Free(pythonioencoding); + Py_XDECREF(bimod); + Py_XDECREF(iomod); + return status; +} + + +/* Print the current exception (if an exception is set) with its traceback, + * or display the current Python stack. + * + * Don't call PyErr_PrintEx() and the except hook, because Py_FatalError() is + * called on catastrophic cases. */ + +static void +_Py_PrintFatalError(int fd) +{ + PyObject *ferr, *res; + PyObject *exception, *v, *tb; + int has_tb; + PyThreadState *tstate; + + PyErr_Fetch(&exception, &v, &tb); + if (exception == NULL) { + /* No current exception */ + goto display_stack; + } + + ferr = _PySys_GetObjectId(&PyId_stderr); + if (ferr == NULL || ferr == Py_None) { + /* sys.stderr is not set yet or set to None, + no need to try to display the exception */ + goto display_stack; + } + + PyErr_NormalizeException(&exception, &v, &tb); + if (tb == NULL) { + tb = Py_None; + Py_INCREF(tb); + } + PyException_SetTraceback(v, tb); + if (exception == NULL) { + /* PyErr_NormalizeException() failed */ + goto display_stack; + } + + has_tb = (tb != Py_None); + PyErr_Display(exception, v, tb); + Py_XDECREF(exception); + Py_XDECREF(v); + Py_XDECREF(tb); + + /* sys.stderr may be buffered: call sys.stderr.flush() */ + res = _PyObject_CallMethodId(ferr, &PyId_flush, ""); + if (res == NULL) + PyErr_Clear(); + else + Py_DECREF(res); + + if (has_tb) + return; + +display_stack: +#ifdef WITH_THREAD + /* PyGILState_GetThisThreadState() works even if the GIL was released */ + tstate = PyGILState_GetThisThreadState(); +#else + tstate = PyThreadState_GET(); +#endif + if (tstate == NULL) { + /* _Py_DumpTracebackThreads() requires the thread state to display + * frames */ + return; + } + + fputc('\n', stderr); + fflush(stderr); + + /* display the current Python stack */ + _Py_DumpTracebackThreads(fd, tstate->interp, tstate); +} +/* Print fatal error message and abort */ + +void +Py_FatalError(const char *msg) +{ + const int fd = fileno(stderr); + static int reentrant = 0; +#ifdef MS_WINDOWS + size_t len; + WCHAR* buffer; + size_t i; +#endif + + if (reentrant) { + /* Py_FatalError() caused a second fatal error. + Example: flush_std_files() raises a recursion error. */ + goto exit; + } + reentrant = 1; + + fprintf(stderr, "Fatal Python error: %s\n", msg); + fflush(stderr); /* it helps in Windows debug build */ + + /* Print the exception (if an exception is set) with its traceback, + * or display the current Python stack. */ + _Py_PrintFatalError(fd); + + /* Flush sys.stdout and sys.stderr */ + flush_std_files(); + + /* The main purpose of faulthandler is to display the traceback. We already + * did our best to display it. So faulthandler can now be disabled. + * (Don't trigger it on abort().) */ + _PyFaulthandler_Fini(); + +#ifdef MS_WINDOWS + len = strlen(msg); + + /* Convert the message to wchar_t. This uses a simple one-to-one + conversion, assuming that the this error message actually uses ASCII + only. If this ceases to be true, we will have to convert. */ + buffer = alloca( (len+1) * (sizeof *buffer)); + for( i=0; i<=len; ++i) + buffer[i] = msg[i]; + OutputDebugStringW(L"Fatal Python error: "); + OutputDebugStringW(buffer); + OutputDebugStringW(L"\n"); +#endif /* MS_WINDOWS */ + +exit: +#if defined(MS_WINDOWS) && defined(_DEBUG) + DebugBreak(); +#endif + abort(); +} + +/* Clean up and exit */ + +#ifdef WITH_THREAD +#include "pythread.h" +#endif + +static void (*pyexitfunc)(void) = NULL; +/* For the atexit module. */ +void _Py_PyAtExit(void (*func)(void)) +{ + pyexitfunc = func; +} + +static void +call_py_exitfuncs(void) +{ + if (pyexitfunc == NULL) + return; + + (*pyexitfunc)(); + PyErr_Clear(); +} + +/* Wait until threading._shutdown completes, provided + the threading module was imported in the first place. + The shutdown routine will wait until all non-daemon + "threading" threads have completed. */ +static void +wait_for_thread_shutdown(void) +{ +#ifdef WITH_THREAD + _Py_IDENTIFIER(_shutdown); + PyObject *result; + PyThreadState *tstate = PyThreadState_GET(); + PyObject *threading = PyMapping_GetItemString(tstate->interp->modules, + "threading"); + if (threading == NULL) { + /* threading not imported */ + PyErr_Clear(); + return; + } + result = _PyObject_CallMethodId(threading, &PyId__shutdown, ""); + if (result == NULL) { + PyErr_WriteUnraisable(threading); + } + else { + Py_DECREF(result); + } + Py_DECREF(threading); +#endif +} + +#define NEXITFUNCS 32 +static void (*exitfuncs[NEXITFUNCS])(void); +static int nexitfuncs = 0; + +int Py_AtExit(void (*func)(void)) +{ + if (nexitfuncs >= NEXITFUNCS) + return -1; + exitfuncs[nexitfuncs++] = func; + return 0; +} + +static void +call_ll_exitfuncs(void) +{ + while (nexitfuncs > 0) + (*exitfuncs[--nexitfuncs])(); + + fflush(stdout); + fflush(stderr); +} + +void +Py_Exit(int sts) +{ + Py_Finalize(); + + exit(sts); +} + +static void +initsigs(void) +{ +#ifdef SIGPIPE + PyOS_setsig(SIGPIPE, SIG_IGN); +#endif +#ifdef SIGXFZ + PyOS_setsig(SIGXFZ, SIG_IGN); +#endif +#ifdef SIGXFSZ + PyOS_setsig(SIGXFSZ, SIG_IGN); +#endif + PyOS_InitInterrupts(); /* May imply initsignal() */ + if (PyErr_Occurred()) { + Py_FatalError("Py_Initialize: can't import signal"); + } +} + + +/* Restore signals that the interpreter has called SIG_IGN on to SIG_DFL. + * + * All of the code in this function must only use async-signal-safe functions, + * listed at `man 7 signal` or + * http://www.opengroup.org/onlinepubs/009695399/functions/xsh_chap02_04.html. + */ +void +_Py_RestoreSignals(void) +{ +#ifdef SIGPIPE + PyOS_setsig(SIGPIPE, SIG_DFL); +#endif +#ifdef SIGXFZ + PyOS_setsig(SIGXFZ, SIG_DFL); +#endif +#ifdef SIGXFSZ + PyOS_setsig(SIGXFSZ, SIG_DFL); +#endif +} + + +/* + * The file descriptor fd is considered ``interactive'' if either + * a) isatty(fd) is TRUE, or + * b) the -i flag was given, and the filename associated with + * the descriptor is NULL or "<stdin>" or "???". + */ +int +Py_FdIsInteractive(FILE *fp, const char *filename) +{ + if (isatty((int)fileno(fp))) + return 1; + if (!Py_InteractiveFlag) + return 0; + return (filename == NULL) || + (strcmp(filename, "<stdin>") == 0) || + (strcmp(filename, "???") == 0); +} + + +/* Wrappers around sigaction() or signal(). */ + +PyOS_sighandler_t +PyOS_getsig(int sig) +{ +#ifdef HAVE_SIGACTION + struct sigaction context; + if (sigaction(sig, NULL, &context) == -1) + return SIG_ERR; + return context.sa_handler; +#else + PyOS_sighandler_t handler; +/* Special signal handling for the secure CRT in Visual Studio 2005 */ +#if defined(_MSC_VER) && _MSC_VER >= 1400 + switch (sig) { + /* Only these signals are valid */ + case SIGINT: + case SIGILL: + case SIGFPE: + case SIGSEGV: + case SIGTERM: + case SIGBREAK: + case SIGABRT: + break; + /* Don't call signal() with other values or it will assert */ + default: + return SIG_ERR; + } +#endif /* _MSC_VER && _MSC_VER >= 1400 */ + handler = signal(sig, SIG_IGN); + if (handler != SIG_ERR) + signal(sig, handler); + return handler; +#endif +} + +/* + * All of the code in this function must only use async-signal-safe functions, + * listed at `man 7 signal` or + * http://www.opengroup.org/onlinepubs/009695399/functions/xsh_chap02_04.html. + */ +PyOS_sighandler_t +PyOS_setsig(int sig, PyOS_sighandler_t handler) +{ +#ifdef HAVE_SIGACTION + /* Some code in Modules/signalmodule.c depends on sigaction() being + * used here if HAVE_SIGACTION is defined. Fix that if this code + * changes to invalidate that assumption. + */ + struct sigaction context, ocontext; + context.sa_handler = handler; + sigemptyset(&context.sa_mask); + context.sa_flags = 0; + if (sigaction(sig, &context, &ocontext) == -1) + return SIG_ERR; + return ocontext.sa_handler; +#else + PyOS_sighandler_t oldhandler; + oldhandler = signal(sig, handler); +#ifdef HAVE_SIGINTERRUPT + siginterrupt(sig, 1); +#endif + return oldhandler; +#endif +} + +#ifdef __cplusplus +} +#endif diff --git a/Python/pystate.c b/Python/pystate.c index 2ac2fd5274..7e0267ae1d 100644 --- a/Python/pystate.c +++ b/Python/pystate.c @@ -212,6 +212,9 @@ new_threadstate(PyInterpreterState *interp, int init) tstate->on_delete = NULL; tstate->on_delete_data = NULL; + tstate->coroutine_wrapper = NULL; + tstate->in_coroutine_wrapper = 0; + if (init) _PyThreadState_Init(tstate); @@ -253,6 +256,9 @@ PyState_FindModule(struct PyModuleDef* module) Py_ssize_t index = module->m_base.m_index; PyInterpreterState *state = PyThreadState_GET()->interp; PyObject *res; + if (module->m_slots) { + return NULL; + } if (index == 0) return NULL; if (state->modules_by_index == NULL) @@ -266,7 +272,13 @@ PyState_FindModule(struct PyModuleDef* module) int _PyState_AddModule(PyObject* module, struct PyModuleDef* def) { - PyInterpreterState *state = PyThreadState_GET()->interp; + PyInterpreterState *state; + if (def->m_slots) { + PyErr_SetString(PyExc_SystemError, + "PyState_AddModule called on module with slots"); + return -1; + } + state = PyThreadState_GET()->interp; if (!def) return -1; if (!state->modules_by_index) { @@ -306,8 +318,14 @@ PyState_AddModule(PyObject* module, struct PyModuleDef* def) int PyState_RemoveModule(struct PyModuleDef* def) { + PyInterpreterState *state; Py_ssize_t index = def->m_base.m_index; - PyInterpreterState *state = PyThreadState_GET()->interp; + if (def->m_slots) { + PyErr_SetString(PyExc_SystemError, + "PyState_RemoveModule called on module with slots"); + return -1; + } + state = PyThreadState_GET()->interp; if (index == 0) { Py_FatalError("PyState_RemoveModule: Module index invalid."); return -1; @@ -372,6 +390,8 @@ PyThreadState_Clear(PyThreadState *tstate) tstate->c_tracefunc = NULL; Py_CLEAR(tstate->c_profileobj); Py_CLEAR(tstate->c_traceobj); + + Py_CLEAR(tstate->coroutine_wrapper); } @@ -403,7 +423,7 @@ tstate_delete_common(PyThreadState *tstate) void PyThreadState_Delete(PyThreadState *tstate) { - if (tstate == _Py_atomic_load_relaxed(&_PyThreadState_Current)) + if (tstate == (PyThreadState*)_Py_atomic_load_relaxed(&_PyThreadState_Current)) Py_FatalError("PyThreadState_Delete: tstate is still current"); #ifdef WITH_THREAD if (autoInterpreterState && PyThread_get_key_value(autoTLSkey) == tstate) @@ -662,7 +682,7 @@ PyThreadState_IsCurrent(PyThreadState *tstate) { /* Must be the tstate for this thread */ assert(PyGILState_GetThisThreadState()==tstate); - return tstate == _Py_atomic_load_relaxed(&_PyThreadState_Current); + return tstate == (PyThreadState*)_Py_atomic_load_relaxed(&_PyThreadState_Current); } /* Internal initialization/finalization functions called by diff --git a/Python/pystrhex.c b/Python/pystrhex.c new file mode 100644 index 0000000000..1259ed12df --- /dev/null +++ b/Python/pystrhex.c @@ -0,0 +1,61 @@ +/* bytes to hex implementation */ + +#include "Python.h" + +static PyObject *_Py_strhex_impl(const char* argbuf, const Py_ssize_t arglen, + int return_bytes) +{ + PyObject *retval; + Py_UCS1* retbuf; + Py_ssize_t i, j; + + assert(arglen >= 0); + if (arglen > PY_SSIZE_T_MAX / 2) + return PyErr_NoMemory(); + + if (return_bytes) { + /* If _PyBytes_FromSize() were public we could avoid malloc+copy. */ + retbuf = (Py_UCS1*) PyMem_Malloc(arglen*2); + if (!retbuf) + return PyErr_NoMemory(); + retval = NULL; /* silence a compiler warning, assigned later. */ + } else { + retval = PyUnicode_New(arglen*2, 127); + if (!retval) + return NULL; + retbuf = PyUnicode_1BYTE_DATA(retval); + } + + /* make hex version of string, taken from shamodule.c */ + for (i=j=0; i < arglen; i++) { + unsigned char c; + c = (argbuf[i] >> 4) & 0xf; + retbuf[j++] = Py_hexdigits[c]; + c = argbuf[i] & 0xf; + retbuf[j++] = Py_hexdigits[c]; + } + + if (return_bytes) { + retval = PyBytes_FromStringAndSize((const char *)retbuf, arglen*2); + PyMem_Free(retbuf); + } +#ifdef Py_DEBUG + else { + assert(_PyUnicode_CheckConsistency(retval, 1)); + } +#endif + + return retval; +} + +PyAPI_FUNC(PyObject *) _Py_strhex(const char* argbuf, const Py_ssize_t arglen) +{ + return _Py_strhex_impl(argbuf, arglen, 0); +} + +/* Same as above but returns a bytes() instead of str() to avoid the + * need to decode the str() when bytes are needed. */ +PyAPI_FUNC(PyObject *) _Py_strhex_bytes(const char* argbuf, const Py_ssize_t arglen) +{ + return _Py_strhex_impl(argbuf, arglen, 1); +} diff --git a/Python/pythonrun.c b/Python/pythonrun.c index 0967a47c57..ebedd123f3 100644 --- a/Python/pythonrun.c +++ b/Python/pythonrun.c @@ -15,6 +15,7 @@ #include "ast.h" #include "marshal.h" #include "osdefs.h" +#include <locale.h> #ifdef HAVE_SIGNAL_H #include <signal.h> @@ -25,18 +26,12 @@ #endif #ifdef HAVE_LANGINFO_H -#include <locale.h> #include <langinfo.h> #endif #ifdef MS_WINDOWS #undef BYTE #include "windows.h" -#define PATH_MAX MAXPATHLEN -#endif - -#ifdef __gnu_hurd__ -#define PATH_MAX MAXPATHLEN #endif _Py_IDENTIFIER(builtins); @@ -45,7 +40,6 @@ _Py_IDENTIFIER(flush); _Py_IDENTIFIER(last_traceback); _Py_IDENTIFIER(last_type); _Py_IDENTIFIER(last_value); -_Py_IDENTIFIER(name); _Py_IDENTIFIER(ps1); _Py_IDENTIFIER(ps2); _Py_IDENTIFIER(stdin); @@ -53,43 +47,13 @@ _Py_IDENTIFIER(stdout); _Py_IDENTIFIER(stderr); _Py_static_string(PyId_string, "<string>"); -#ifdef Py_REF_DEBUG -static -void _print_total_refs(void) { - PyObject *xoptions, *value; - _Py_IDENTIFIER(showrefcount); - - xoptions = PySys_GetXOptions(); - if (xoptions == NULL) - return; - value = _PyDict_GetItemId(xoptions, &PyId_showrefcount); - if (value == Py_True) - fprintf(stderr, - "[%" PY_FORMAT_SIZE_T "d refs, " - "%" PY_FORMAT_SIZE_T "d blocks]\n", - _Py_GetRefTotal(), _Py_GetAllocatedBlocks()); -} -#endif - -#ifndef Py_REF_DEBUG -#define PRINT_TOTAL_REFS() -#else /* Py_REF_DEBUG */ -#define PRINT_TOTAL_REFS() _print_total_refs() -#endif - #ifdef __cplusplus extern "C" { #endif -extern wchar_t *Py_GetPath(void); - extern grammar _PyParser_Grammar; /* From graminit.c */ /* Forward */ -static void initmain(PyInterpreterState *interp); -static int initfsencoding(PyInterpreterState *interp); -static void initsite(void); -static int initstdio(void); static void flush_io(void); static PyObject *run_mod(mod_ty, PyObject *, PyObject *, PyObject *, PyCompilerFlags *, PyArena *); @@ -97,1177 +61,6 @@ static PyObject *run_pyc_file(FILE *, const char *, PyObject *, PyObject *, PyCompilerFlags *); static void err_input(perrdetail *); static void err_free(perrdetail *); -static void initsigs(void); -static void call_py_exitfuncs(void); -static void wait_for_thread_shutdown(void); -static void call_ll_exitfuncs(void); -extern int _PyUnicode_Init(void); -extern int _PyStructSequence_Init(void); -extern void _PyUnicode_Fini(void); -extern int _PyLong_Init(void); -extern void PyLong_Fini(void); -extern int _PyFaulthandler_Init(void); -extern void _PyFaulthandler_Fini(void); -extern void _PyHash_Fini(void); -extern int _PyTraceMalloc_Init(void); -extern int _PyTraceMalloc_Fini(void); - -#ifdef WITH_THREAD -extern void _PyGILState_Init(PyInterpreterState *, PyThreadState *); -extern void _PyGILState_Fini(void); -#endif /* WITH_THREAD */ - -int Py_DebugFlag; /* Needed by parser.c */ -int Py_VerboseFlag; /* Needed by import.c */ -int Py_QuietFlag; /* Needed by sysmodule.c */ -int Py_InteractiveFlag; /* Needed by Py_FdIsInteractive() below */ -int Py_InspectFlag; /* Needed to determine whether to exit at SystemExit */ -int Py_NoSiteFlag; /* Suppress 'import site' */ -int Py_BytesWarningFlag; /* Warn on str(bytes) and str(buffer) */ -int Py_DontWriteBytecodeFlag; /* Suppress writing bytecode files (*.py[co]) */ -int Py_UseClassExceptionsFlag = 1; /* Needed by bltinmodule.c: deprecated */ -int Py_FrozenFlag; /* Needed by getpath.c */ -int Py_IgnoreEnvironmentFlag; /* e.g. PYTHONPATH, PYTHONHOME */ -int Py_NoUserSiteDirectory = 0; /* for -s and site.py */ -int Py_UnbufferedStdioFlag = 0; /* Unbuffered binary std{in,out,err} */ -int Py_HashRandomizationFlag = 0; /* for -R and PYTHONHASHSEED */ -int Py_IsolatedFlag = 0; /* for -I, isolate from user's env */ - -PyThreadState *_Py_Finalizing = NULL; - -/* Hack to force loading of object files */ -int (*_PyOS_mystrnicmp_hack)(const char *, const char *, Py_ssize_t) = \ - PyOS_mystrnicmp; /* Python/pystrcmp.o */ - -/* PyModule_GetWarningsModule is no longer necessary as of 2.6 -since _warnings is builtin. This API should not be used. */ -PyObject * -PyModule_GetWarningsModule(void) -{ - return PyImport_ImportModule("warnings"); -} - -static int initialized = 0; - -/* API to access the initialized flag -- useful for esoteric use */ - -int -Py_IsInitialized(void) -{ - return initialized; -} - -/* Helper to allow an embedding application to override the normal - * mechanism that attempts to figure out an appropriate IO encoding - */ - -static char *_Py_StandardStreamEncoding = NULL; -static char *_Py_StandardStreamErrors = NULL; - -int -Py_SetStandardStreamEncoding(const char *encoding, const char *errors) -{ - if (Py_IsInitialized()) { - /* This is too late to have any effect */ - return -1; - } - /* Can't call PyErr_NoMemory() on errors, as Python hasn't been - * initialised yet. - * - * However, the raw memory allocators are initialised appropriately - * as C static variables, so _PyMem_RawStrdup is OK even though - * Py_Initialize hasn't been called yet. - */ - if (encoding) { - _Py_StandardStreamEncoding = _PyMem_RawStrdup(encoding); - if (!_Py_StandardStreamEncoding) { - return -2; - } - } - if (errors) { - _Py_StandardStreamErrors = _PyMem_RawStrdup(errors); - if (!_Py_StandardStreamErrors) { - if (_Py_StandardStreamEncoding) { - PyMem_RawFree(_Py_StandardStreamEncoding); - } - return -3; - } - } - return 0; -} - -/* Global initializations. Can be undone by Py_Finalize(). Don't - call this twice without an intervening Py_Finalize() call. When - initializations fail, a fatal error is issued and the function does - not return. On return, the first thread and interpreter state have - been created. - - Locking: you must hold the interpreter lock while calling this. - (If the lock has not yet been initialized, that's equivalent to - having the lock, but you cannot use multiple threads.) - -*/ - -static int -add_flag(int flag, const char *envs) -{ - int env = atoi(envs); - if (flag < env) - flag = env; - if (flag < 1) - flag = 1; - return flag; -} - -static char* -get_codec_name(const char *encoding) -{ - char *name_utf8, *name_str; - PyObject *codec, *name = NULL; - - codec = _PyCodec_Lookup(encoding); - if (!codec) - goto error; - - name = _PyObject_GetAttrId(codec, &PyId_name); - Py_CLEAR(codec); - if (!name) - goto error; - - name_utf8 = _PyUnicode_AsString(name); - if (name_utf8 == NULL) - goto error; - name_str = _PyMem_RawStrdup(name_utf8); - Py_DECREF(name); - if (name_str == NULL) { - PyErr_NoMemory(); - return NULL; - } - return name_str; - -error: - Py_XDECREF(codec); - Py_XDECREF(name); - return NULL; -} - -static char* -get_locale_encoding(void) -{ -#ifdef MS_WINDOWS - char codepage[100]; - PyOS_snprintf(codepage, sizeof(codepage), "cp%d", GetACP()); - return get_codec_name(codepage); -#elif defined(HAVE_LANGINFO_H) && defined(CODESET) - char* codeset = nl_langinfo(CODESET); - if (!codeset || codeset[0] == '\0') { - PyErr_SetString(PyExc_ValueError, "CODESET is not set or empty"); - return NULL; - } - return get_codec_name(codeset); -#else - PyErr_SetNone(PyExc_NotImplementedError); - return NULL; -#endif -} - -static void -import_init(PyInterpreterState *interp, PyObject *sysmod) -{ - PyObject *importlib; - PyObject *impmod; - PyObject *sys_modules; - PyObject *value; - - /* Import _importlib through its frozen version, _frozen_importlib. */ - if (PyImport_ImportFrozenModule("_frozen_importlib") <= 0) { - Py_FatalError("Py_Initialize: can't import _frozen_importlib"); - } - else if (Py_VerboseFlag) { - PySys_FormatStderr("import _frozen_importlib # frozen\n"); - } - importlib = PyImport_AddModule("_frozen_importlib"); - if (importlib == NULL) { - Py_FatalError("Py_Initialize: couldn't get _frozen_importlib from " - "sys.modules"); - } - interp->importlib = importlib; - Py_INCREF(interp->importlib); - - /* Install _importlib as __import__ */ - impmod = PyInit_imp(); - if (impmod == NULL) { - Py_FatalError("Py_Initialize: can't import imp"); - } - else if (Py_VerboseFlag) { - PySys_FormatStderr("import imp # builtin\n"); - } - sys_modules = PyImport_GetModuleDict(); - if (Py_VerboseFlag) { - PySys_FormatStderr("import sys # builtin\n"); - } - if (PyDict_SetItemString(sys_modules, "_imp", impmod) < 0) { - Py_FatalError("Py_Initialize: can't save _imp to sys.modules"); - } - - value = PyObject_CallMethod(importlib, "_install", "OO", sysmod, impmod); - if (value == NULL) { - PyErr_Print(); - Py_FatalError("Py_Initialize: importlib install failed"); - } - Py_DECREF(value); - Py_DECREF(impmod); - - _PyImportZip_Init(); -} - - -void -_Py_InitializeEx_Private(int install_sigs, int install_importlib) -{ - PyInterpreterState *interp; - PyThreadState *tstate; - PyObject *bimod, *sysmod, *pstderr; - char *p; - extern void _Py_ReadyTypes(void); - - if (initialized) - return; - initialized = 1; - _Py_Finalizing = NULL; - -#if defined(HAVE_LANGINFO_H) && defined(HAVE_SETLOCALE) - /* Set up the LC_CTYPE locale, so we can obtain - the locale's charset without having to switch - locales. */ - setlocale(LC_CTYPE, ""); -#endif - - if ((p = Py_GETENV("PYTHONDEBUG")) && *p != '\0') - Py_DebugFlag = add_flag(Py_DebugFlag, p); - if ((p = Py_GETENV("PYTHONVERBOSE")) && *p != '\0') - Py_VerboseFlag = add_flag(Py_VerboseFlag, p); - if ((p = Py_GETENV("PYTHONOPTIMIZE")) && *p != '\0') - Py_OptimizeFlag = add_flag(Py_OptimizeFlag, p); - if ((p = Py_GETENV("PYTHONDONTWRITEBYTECODE")) && *p != '\0') - Py_DontWriteBytecodeFlag = add_flag(Py_DontWriteBytecodeFlag, p); - /* The variable is only tested for existence here; _PyRandom_Init will - check its value further. */ - if ((p = Py_GETENV("PYTHONHASHSEED")) && *p != '\0') - Py_HashRandomizationFlag = add_flag(Py_HashRandomizationFlag, p); - - _PyRandom_Init(); - - interp = PyInterpreterState_New(); - if (interp == NULL) - Py_FatalError("Py_Initialize: can't make first interpreter"); - - tstate = PyThreadState_New(interp); - if (tstate == NULL) - Py_FatalError("Py_Initialize: can't make first thread"); - (void) PyThreadState_Swap(tstate); - -#ifdef WITH_THREAD - /* We can't call _PyEval_FiniThreads() in Py_Finalize because - destroying the GIL might fail when it is being referenced from - another running thread (see issue #9901). - Instead we destroy the previously created GIL here, which ensures - that we can call Py_Initialize / Py_Finalize multiple times. */ - _PyEval_FiniThreads(); - - /* Auto-thread-state API */ - _PyGILState_Init(interp, tstate); -#endif /* WITH_THREAD */ - - _Py_ReadyTypes(); - - if (!_PyFrame_Init()) - Py_FatalError("Py_Initialize: can't init frames"); - - if (!_PyLong_Init()) - Py_FatalError("Py_Initialize: can't init longs"); - - if (!PyByteArray_Init()) - Py_FatalError("Py_Initialize: can't init bytearray"); - - if (!_PyFloat_Init()) - Py_FatalError("Py_Initialize: can't init float"); - - interp->modules = PyDict_New(); - if (interp->modules == NULL) - Py_FatalError("Py_Initialize: can't make modules dictionary"); - - /* Init Unicode implementation; relies on the codec registry */ - if (_PyUnicode_Init() < 0) - Py_FatalError("Py_Initialize: can't initialize unicode"); - if (_PyStructSequence_Init() < 0) - Py_FatalError("Py_Initialize: can't initialize structseq"); - - bimod = _PyBuiltin_Init(); - if (bimod == NULL) - Py_FatalError("Py_Initialize: can't initialize builtins modules"); - _PyImport_FixupBuiltin(bimod, "builtins"); - interp->builtins = PyModule_GetDict(bimod); - if (interp->builtins == NULL) - Py_FatalError("Py_Initialize: can't initialize builtins dict"); - Py_INCREF(interp->builtins); - - /* initialize builtin exceptions */ - _PyExc_Init(bimod); - - sysmod = _PySys_Init(); - if (sysmod == NULL) - Py_FatalError("Py_Initialize: can't initialize sys"); - interp->sysdict = PyModule_GetDict(sysmod); - if (interp->sysdict == NULL) - Py_FatalError("Py_Initialize: can't initialize sys dict"); - Py_INCREF(interp->sysdict); - _PyImport_FixupBuiltin(sysmod, "sys"); - PySys_SetPath(Py_GetPath()); - PyDict_SetItemString(interp->sysdict, "modules", - interp->modules); - - /* Set up a preliminary stderr printer until we have enough - infrastructure for the io module in place. */ - pstderr = PyFile_NewStdPrinter(fileno(stderr)); - if (pstderr == NULL) - Py_FatalError("Py_Initialize: can't set preliminary stderr"); - _PySys_SetObjectId(&PyId_stderr, pstderr); - PySys_SetObject("__stderr__", pstderr); - Py_DECREF(pstderr); - - _PyImport_Init(); - - _PyImportHooks_Init(); - - /* Initialize _warnings. */ - _PyWarnings_Init(); - - if (!install_importlib) - return; - - import_init(interp, sysmod); - - /* initialize the faulthandler module */ - if (_PyFaulthandler_Init()) - Py_FatalError("Py_Initialize: can't initialize faulthandler"); - - _PyTime_Init(); - - if (initfsencoding(interp) < 0) - Py_FatalError("Py_Initialize: unable to load the file system codec"); - - if (install_sigs) - initsigs(); /* Signal handling stuff, including initintr() */ - - if (_PyTraceMalloc_Init() < 0) - Py_FatalError("Py_Initialize: can't initialize tracemalloc"); - - initmain(interp); /* Module __main__ */ - if (initstdio() < 0) - Py_FatalError( - "Py_Initialize: can't initialize sys standard streams"); - - /* Initialize warnings. */ - if (PySys_HasWarnOptions()) { - PyObject *warnings_module = PyImport_ImportModule("warnings"); - if (warnings_module == NULL) { - fprintf(stderr, "'import warnings' failed; traceback:\n"); - PyErr_Print(); - } - Py_XDECREF(warnings_module); - } - - if (!Py_NoSiteFlag) - initsite(); /* Module site */ -} - -void -Py_InitializeEx(int install_sigs) -{ - _Py_InitializeEx_Private(install_sigs, 1); -} - -void -Py_Initialize(void) -{ - Py_InitializeEx(1); -} - - -#ifdef COUNT_ALLOCS -extern void dump_counts(FILE*); -#endif - -/* Flush stdout and stderr */ - -static int -file_is_closed(PyObject *fobj) -{ - int r; - PyObject *tmp = PyObject_GetAttrString(fobj, "closed"); - if (tmp == NULL) { - PyErr_Clear(); - return 0; - } - r = PyObject_IsTrue(tmp); - Py_DECREF(tmp); - if (r < 0) - PyErr_Clear(); - return r > 0; -} - -static void -flush_std_files(void) -{ - PyObject *fout = _PySys_GetObjectId(&PyId_stdout); - PyObject *ferr = _PySys_GetObjectId(&PyId_stderr); - PyObject *tmp; - - if (fout != NULL && fout != Py_None && !file_is_closed(fout)) { - tmp = _PyObject_CallMethodId(fout, &PyId_flush, ""); - if (tmp == NULL) - PyErr_WriteUnraisable(fout); - else - Py_DECREF(tmp); - } - - if (ferr != NULL && ferr != Py_None && !file_is_closed(ferr)) { - tmp = _PyObject_CallMethodId(ferr, &PyId_flush, ""); - if (tmp == NULL) - PyErr_Clear(); - else - Py_DECREF(tmp); - } -} - -/* Undo the effect of Py_Initialize(). - - Beware: if multiple interpreter and/or thread states exist, these - are not wiped out; only the current thread and interpreter state - are deleted. But since everything else is deleted, those other - interpreter and thread states should no longer be used. - - (XXX We should do better, e.g. wipe out all interpreters and - threads.) - - Locking: as above. - -*/ - -void -Py_Finalize(void) -{ - PyInterpreterState *interp; - PyThreadState *tstate; - - if (!initialized) - return; - - wait_for_thread_shutdown(); - - /* The interpreter is still entirely intact at this point, and the - * exit funcs may be relying on that. In particular, if some thread - * or exit func is still waiting to do an import, the import machinery - * expects Py_IsInitialized() to return true. So don't say the - * interpreter is uninitialized until after the exit funcs have run. - * Note that Threading.py uses an exit func to do a join on all the - * threads created thru it, so this also protects pending imports in - * the threads created via Threading. - */ - call_py_exitfuncs(); - - /* Get current thread state and interpreter pointer */ - tstate = PyThreadState_GET(); - interp = tstate->interp; - - /* Remaining threads (e.g. daemon threads) will automatically exit - after taking the GIL (in PyEval_RestoreThread()). */ - _Py_Finalizing = tstate; - initialized = 0; - - /* Flush sys.stdout and sys.stderr */ - flush_std_files(); - - /* Disable signal handling */ - PyOS_FiniInterrupts(); - - /* Collect garbage. This may call finalizers; it's nice to call these - * before all modules are destroyed. - * XXX If a __del__ or weakref callback is triggered here, and tries to - * XXX import a module, bad things can happen, because Python no - * XXX longer believes it's initialized. - * XXX Fatal Python error: Interpreter not initialized (version mismatch?) - * XXX is easy to provoke that way. I've also seen, e.g., - * XXX Exception exceptions.ImportError: 'No module named sha' - * XXX in <function callback at 0x008F5718> ignored - * XXX but I'm unclear on exactly how that one happens. In any case, - * XXX I haven't seen a real-life report of either of these. - */ - PyGC_Collect(); -#ifdef COUNT_ALLOCS - /* With COUNT_ALLOCS, it helps to run GC multiple times: - each collection might release some types from the type - list, so they become garbage. */ - while (PyGC_Collect() > 0) - /* nothing */; -#endif - /* Destroy all modules */ - PyImport_Cleanup(); - - /* Flush sys.stdout and sys.stderr (again, in case more was printed) */ - flush_std_files(); - - /* Collect final garbage. This disposes of cycles created by - * class definitions, for example. - * XXX This is disabled because it caused too many problems. If - * XXX a __del__ or weakref callback triggers here, Python code has - * XXX a hard time running, because even the sys module has been - * XXX cleared out (sys.stdout is gone, sys.excepthook is gone, etc). - * XXX One symptom is a sequence of information-free messages - * XXX coming from threads (if a __del__ or callback is invoked, - * XXX other threads can execute too, and any exception they encounter - * XXX triggers a comedy of errors as subsystem after subsystem - * XXX fails to find what it *expects* to find in sys to help report - * XXX the exception and consequent unexpected failures). I've also - * XXX seen segfaults then, after adding print statements to the - * XXX Python code getting called. - */ -#if 0 - PyGC_Collect(); -#endif - - /* Disable tracemalloc after all Python objects have been destroyed, - so it is possible to use tracemalloc in objects destructor. */ - _PyTraceMalloc_Fini(); - - /* Destroy the database used by _PyImport_{Fixup,Find}Extension */ - _PyImport_Fini(); - - /* Cleanup typeobject.c's internal caches. */ - _PyType_Fini(); - - /* unload faulthandler module */ - _PyFaulthandler_Fini(); - - /* Debugging stuff */ -#ifdef COUNT_ALLOCS - dump_counts(stdout); -#endif - /* dump hash stats */ - _PyHash_Fini(); - - PRINT_TOTAL_REFS(); - -#ifdef Py_TRACE_REFS - /* Display all objects still alive -- this can invoke arbitrary - * __repr__ overrides, so requires a mostly-intact interpreter. - * Alas, a lot of stuff may still be alive now that will be cleaned - * up later. - */ - if (Py_GETENV("PYTHONDUMPREFS")) - _Py_PrintReferences(stderr); -#endif /* Py_TRACE_REFS */ - - /* Clear interpreter state and all thread states. */ - PyInterpreterState_Clear(interp); - - /* Now we decref the exception classes. After this point nothing - can raise an exception. That's okay, because each Fini() method - below has been checked to make sure no exceptions are ever - raised. - */ - - _PyExc_Fini(); - - /* Sundry finalizers */ - PyMethod_Fini(); - PyFrame_Fini(); - PyCFunction_Fini(); - PyTuple_Fini(); - PyList_Fini(); - PySet_Fini(); - PyBytes_Fini(); - PyByteArray_Fini(); - PyLong_Fini(); - PyFloat_Fini(); - PyDict_Fini(); - PySlice_Fini(); - _PyGC_Fini(); - _PyRandom_Fini(); - - /* Cleanup Unicode implementation */ - _PyUnicode_Fini(); - - /* reset file system default encoding */ - if (!Py_HasFileSystemDefaultEncoding && Py_FileSystemDefaultEncoding) { - PyMem_RawFree((char*)Py_FileSystemDefaultEncoding); - Py_FileSystemDefaultEncoding = NULL; - } - - /* XXX Still allocated: - - various static ad-hoc pointers to interned strings - - int and float free list blocks - - whatever various modules and libraries allocate - */ - - PyGrammar_RemoveAccelerators(&_PyParser_Grammar); - - /* Cleanup auto-thread-state */ -#ifdef WITH_THREAD - _PyGILState_Fini(); -#endif /* WITH_THREAD */ - - /* Delete current thread. After this, many C API calls become crashy. */ - PyThreadState_Swap(NULL); - PyInterpreterState_Delete(interp); - -#ifdef Py_TRACE_REFS - /* Display addresses (& refcnts) of all objects still alive. - * An address can be used to find the repr of the object, printed - * above by _Py_PrintReferences. - */ - if (Py_GETENV("PYTHONDUMPREFS")) - _Py_PrintReferenceAddresses(stderr); -#endif /* Py_TRACE_REFS */ -#ifdef PYMALLOC_DEBUG - if (Py_GETENV("PYTHONMALLOCSTATS")) - _PyObject_DebugMallocStats(stderr); -#endif - - call_ll_exitfuncs(); -} - -/* Create and initialize a new interpreter and thread, and return the - new thread. This requires that Py_Initialize() has been called - first. - - Unsuccessful initialization yields a NULL pointer. Note that *no* - exception information is available even in this case -- the - exception information is held in the thread, and there is no - thread. - - Locking: as above. - -*/ - -PyThreadState * -Py_NewInterpreter(void) -{ - PyInterpreterState *interp; - PyThreadState *tstate, *save_tstate; - PyObject *bimod, *sysmod; - - if (!initialized) - Py_FatalError("Py_NewInterpreter: call Py_Initialize first"); - - interp = PyInterpreterState_New(); - if (interp == NULL) - return NULL; - - tstate = PyThreadState_New(interp); - if (tstate == NULL) { - PyInterpreterState_Delete(interp); - return NULL; - } - - save_tstate = PyThreadState_Swap(tstate); - - /* XXX The following is lax in error checking */ - - interp->modules = PyDict_New(); - - bimod = _PyImport_FindBuiltin("builtins"); - if (bimod != NULL) { - interp->builtins = PyModule_GetDict(bimod); - if (interp->builtins == NULL) - goto handle_error; - Py_INCREF(interp->builtins); - } - - /* initialize builtin exceptions */ - _PyExc_Init(bimod); - - sysmod = _PyImport_FindBuiltin("sys"); - if (bimod != NULL && sysmod != NULL) { - PyObject *pstderr; - - interp->sysdict = PyModule_GetDict(sysmod); - if (interp->sysdict == NULL) - goto handle_error; - Py_INCREF(interp->sysdict); - PySys_SetPath(Py_GetPath()); - PyDict_SetItemString(interp->sysdict, "modules", - interp->modules); - /* Set up a preliminary stderr printer until we have enough - infrastructure for the io module in place. */ - pstderr = PyFile_NewStdPrinter(fileno(stderr)); - if (pstderr == NULL) - Py_FatalError("Py_Initialize: can't set preliminary stderr"); - _PySys_SetObjectId(&PyId_stderr, pstderr); - PySys_SetObject("__stderr__", pstderr); - Py_DECREF(pstderr); - - _PyImportHooks_Init(); - - import_init(interp, sysmod); - - if (initfsencoding(interp) < 0) - goto handle_error; - - if (initstdio() < 0) - Py_FatalError( - "Py_Initialize: can't initialize sys standard streams"); - initmain(interp); - if (!Py_NoSiteFlag) - initsite(); - } - - if (!PyErr_Occurred()) - return tstate; - -handle_error: - /* Oops, it didn't work. Undo it all. */ - - PyErr_PrintEx(0); - PyThreadState_Clear(tstate); - PyThreadState_Swap(save_tstate); - PyThreadState_Delete(tstate); - PyInterpreterState_Delete(interp); - - return NULL; -} - -/* Delete an interpreter and its last thread. This requires that the - given thread state is current, that the thread has no remaining - frames, and that it is its interpreter's only remaining thread. - It is a fatal error to violate these constraints. - - (Py_Finalize() doesn't have these constraints -- it zaps - everything, regardless.) - - Locking: as above. - -*/ - -void -Py_EndInterpreter(PyThreadState *tstate) -{ - PyInterpreterState *interp = tstate->interp; - - if (tstate != PyThreadState_GET()) - Py_FatalError("Py_EndInterpreter: thread is not current"); - if (tstate->frame != NULL) - Py_FatalError("Py_EndInterpreter: thread still has a frame"); - - wait_for_thread_shutdown(); - - if (tstate != interp->tstate_head || tstate->next != NULL) - Py_FatalError("Py_EndInterpreter: not the last thread"); - - PyImport_Cleanup(); - PyInterpreterState_Clear(interp); - PyThreadState_Swap(NULL); - PyInterpreterState_Delete(interp); -} - -#ifdef MS_WINDOWS -static wchar_t *progname = L"python"; -#else -static wchar_t *progname = L"python3"; -#endif - -void -Py_SetProgramName(wchar_t *pn) -{ - if (pn && *pn) - progname = pn; -} - -wchar_t * -Py_GetProgramName(void) -{ - return progname; -} - -static wchar_t *default_home = NULL; -static wchar_t env_home[MAXPATHLEN+1]; - -void -Py_SetPythonHome(wchar_t *home) -{ - default_home = home; -} - -wchar_t * -Py_GetPythonHome(void) -{ - wchar_t *home = default_home; - if (home == NULL && !Py_IgnoreEnvironmentFlag) { - char* chome = Py_GETENV("PYTHONHOME"); - if (chome) { - size_t size = Py_ARRAY_LENGTH(env_home); - size_t r = mbstowcs(env_home, chome, size); - if (r != (size_t)-1 && r < size) - home = env_home; - } - - } - return home; -} - -/* Create __main__ module */ - -static void -initmain(PyInterpreterState *interp) -{ - PyObject *m, *d, *loader; - m = PyImport_AddModule("__main__"); - if (m == NULL) - Py_FatalError("can't create __main__ module"); - d = PyModule_GetDict(m); - if (PyDict_GetItemString(d, "__builtins__") == NULL) { - PyObject *bimod = PyImport_ImportModule("builtins"); - if (bimod == NULL) { - Py_FatalError("Failed to retrieve builtins module"); - } - if (PyDict_SetItemString(d, "__builtins__", bimod) < 0) { - Py_FatalError("Failed to initialize __main__.__builtins__"); - } - Py_DECREF(bimod); - } - /* Main is a little special - imp.is_builtin("__main__") will return - * False, but BuiltinImporter is still the most appropriate initial - * setting for its __loader__ attribute. A more suitable value will - * be set if __main__ gets further initialized later in the startup - * process. - */ - loader = PyDict_GetItemString(d, "__loader__"); - if (loader == NULL || loader == Py_None) { - PyObject *loader = PyObject_GetAttrString(interp->importlib, - "BuiltinImporter"); - if (loader == NULL) { - Py_FatalError("Failed to retrieve BuiltinImporter"); - } - if (PyDict_SetItemString(d, "__loader__", loader) < 0) { - Py_FatalError("Failed to initialize __main__.__loader__"); - } - Py_DECREF(loader); - } -} - -static int -initfsencoding(PyInterpreterState *interp) -{ - PyObject *codec; - - if (Py_FileSystemDefaultEncoding == NULL) - { - Py_FileSystemDefaultEncoding = get_locale_encoding(); - if (Py_FileSystemDefaultEncoding == NULL) - Py_FatalError("Py_Initialize: Unable to get the locale encoding"); - - Py_HasFileSystemDefaultEncoding = 0; - interp->fscodec_initialized = 1; - return 0; - } - - /* the encoding is mbcs, utf-8 or ascii */ - codec = _PyCodec_Lookup(Py_FileSystemDefaultEncoding); - if (!codec) { - /* Such error can only occurs in critical situations: no more - * memory, import a module of the standard library failed, - * etc. */ - return -1; - } - Py_DECREF(codec); - interp->fscodec_initialized = 1; - return 0; -} - -/* Import the site module (not into __main__ though) */ - -static void -initsite(void) -{ - PyObject *m; - m = PyImport_ImportModule("site"); - if (m == NULL) { - fprintf(stderr, "Failed to import the site module\n"); - PyErr_Print(); - Py_Finalize(); - exit(1); - } - else { - Py_DECREF(m); - } -} - -/* Check if a file descriptor is valid or not. - Return 0 if the file descriptor is invalid, return non-zero otherwise. */ -static int -is_valid_fd(int fd) -{ - int fd2; - if (fd < 0 || !_PyVerify_fd(fd)) - return 0; - fd2 = dup(fd); - if (fd2 >= 0) - close(fd2); - return fd2 >= 0; -} - -/* returns Py_None if the fd is not valid */ -static PyObject* -create_stdio(PyObject* io, - int fd, int write_mode, char* name, - char* encoding, char* errors) -{ - PyObject *buf = NULL, *stream = NULL, *text = NULL, *raw = NULL, *res; - const char* mode; - const char* newline; - PyObject *line_buffering; - int buffering, isatty; - _Py_IDENTIFIER(open); - _Py_IDENTIFIER(isatty); - _Py_IDENTIFIER(TextIOWrapper); - _Py_IDENTIFIER(mode); - - if (!is_valid_fd(fd)) - Py_RETURN_NONE; - - /* stdin is always opened in buffered mode, first because it shouldn't - make a difference in common use cases, second because TextIOWrapper - depends on the presence of a read1() method which only exists on - buffered streams. - */ - if (Py_UnbufferedStdioFlag && write_mode) - buffering = 0; - else - buffering = -1; - if (write_mode) - mode = "wb"; - else - mode = "rb"; - buf = _PyObject_CallMethodId(io, &PyId_open, "isiOOOi", - fd, mode, buffering, - Py_None, Py_None, Py_None, 0); - if (buf == NULL) - goto error; - - if (buffering) { - _Py_IDENTIFIER(raw); - raw = _PyObject_GetAttrId(buf, &PyId_raw); - if (raw == NULL) - goto error; - } - else { - raw = buf; - Py_INCREF(raw); - } - - text = PyUnicode_FromString(name); - if (text == NULL || _PyObject_SetAttrId(raw, &PyId_name, text) < 0) - goto error; - res = _PyObject_CallMethodId(raw, &PyId_isatty, ""); - if (res == NULL) - goto error; - isatty = PyObject_IsTrue(res); - Py_DECREF(res); - if (isatty == -1) - goto error; - if (isatty || Py_UnbufferedStdioFlag) - line_buffering = Py_True; - else - line_buffering = Py_False; - - Py_CLEAR(raw); - Py_CLEAR(text); - -#ifdef MS_WINDOWS - /* sys.stdin: enable universal newline mode, translate "\r\n" and "\r" - newlines to "\n". - sys.stdout and sys.stderr: translate "\n" to "\r\n". */ - newline = NULL; -#else - /* sys.stdin: split lines at "\n". - sys.stdout and sys.stderr: don't translate newlines (use "\n"). */ - newline = "\n"; -#endif - - stream = _PyObject_CallMethodId(io, &PyId_TextIOWrapper, "OsssO", - buf, encoding, errors, - newline, line_buffering); - Py_CLEAR(buf); - if (stream == NULL) - goto error; - - if (write_mode) - mode = "w"; - else - mode = "r"; - text = PyUnicode_FromString(mode); - if (!text || _PyObject_SetAttrId(stream, &PyId_mode, text) < 0) - goto error; - Py_CLEAR(text); - return stream; - -error: - Py_XDECREF(buf); - Py_XDECREF(stream); - Py_XDECREF(text); - Py_XDECREF(raw); - - if (PyErr_ExceptionMatches(PyExc_OSError) && !is_valid_fd(fd)) { - /* Issue #24891: the file descriptor was closed after the first - is_valid_fd() check was called. Ignore the OSError and set the - stream to None. */ - PyErr_Clear(); - Py_RETURN_NONE; - } - return NULL; -} - -/* Initialize sys.stdin, stdout, stderr and builtins.open */ -static int -initstdio(void) -{ - PyObject *iomod = NULL, *wrapper; - PyObject *bimod = NULL; - PyObject *m; - PyObject *std = NULL; - int status = 0, fd; - PyObject * encoding_attr; - char *pythonioencoding = NULL, *encoding, *errors; - - /* Hack to avoid a nasty recursion issue when Python is invoked - in verbose mode: pre-import the Latin-1 and UTF-8 codecs */ - if ((m = PyImport_ImportModule("encodings.utf_8")) == NULL) { - goto error; - } - Py_DECREF(m); - - if (!(m = PyImport_ImportModule("encodings.latin_1"))) { - goto error; - } - Py_DECREF(m); - - if (!(bimod = PyImport_ImportModule("builtins"))) { - goto error; - } - - if (!(iomod = PyImport_ImportModule("io"))) { - goto error; - } - if (!(wrapper = PyObject_GetAttrString(iomod, "OpenWrapper"))) { - goto error; - } - - /* Set builtins.open */ - if (PyObject_SetAttrString(bimod, "open", wrapper) == -1) { - Py_DECREF(wrapper); - goto error; - } - Py_DECREF(wrapper); - - encoding = _Py_StandardStreamEncoding; - errors = _Py_StandardStreamErrors; - if (!encoding || !errors) { - pythonioencoding = Py_GETENV("PYTHONIOENCODING"); - if (pythonioencoding) { - char *err; - pythonioencoding = _PyMem_Strdup(pythonioencoding); - if (pythonioencoding == NULL) { - PyErr_NoMemory(); - goto error; - } - err = strchr(pythonioencoding, ':'); - if (err) { - *err = '\0'; - err++; - if (*err && !errors) { - errors = err; - } - } - if (*pythonioencoding && !encoding) { - encoding = pythonioencoding; - } - } - } - - /* Set sys.stdin */ - fd = fileno(stdin); - /* Under some conditions stdin, stdout and stderr may not be connected - * and fileno() may point to an invalid file descriptor. For example - * GUI apps don't have valid standard streams by default. - */ - std = create_stdio(iomod, fd, 0, "<stdin>", encoding, errors); - if (std == NULL) - goto error; - PySys_SetObject("__stdin__", std); - _PySys_SetObjectId(&PyId_stdin, std); - Py_DECREF(std); - - /* Set sys.stdout */ - fd = fileno(stdout); - std = create_stdio(iomod, fd, 1, "<stdout>", encoding, errors); - if (std == NULL) - goto error; - PySys_SetObject("__stdout__", std); - _PySys_SetObjectId(&PyId_stdout, std); - Py_DECREF(std); - -#if 1 /* Disable this if you have trouble debugging bootstrap stuff */ - /* Set sys.stderr, replaces the preliminary stderr */ - fd = fileno(stderr); - std = create_stdio(iomod, fd, 1, "<stderr>", encoding, "backslashreplace"); - if (std == NULL) - goto error; - - /* Same as hack above, pre-import stderr's codec to avoid recursion - when import.c tries to write to stderr in verbose mode. */ - encoding_attr = PyObject_GetAttrString(std, "encoding"); - if (encoding_attr != NULL) { - const char * std_encoding; - std_encoding = _PyUnicode_AsString(encoding_attr); - if (std_encoding != NULL) { - PyObject *codec_info = _PyCodec_Lookup(std_encoding); - Py_XDECREF(codec_info); - } - Py_DECREF(encoding_attr); - } - PyErr_Clear(); /* Not a fatal error if codec isn't available */ - - if (PySys_SetObject("__stderr__", std) < 0) { - Py_DECREF(std); - goto error; - } - if (_PySys_SetObjectId(&PyId_stderr, std) < 0) { - Py_DECREF(std); - goto error; - } - Py_DECREF(std); -#endif - - if (0) { - error: - status = -1; - } - - /* We won't need them anymore. */ - if (_Py_StandardStreamEncoding) { - PyMem_RawFree(_Py_StandardStreamEncoding); - _Py_StandardStreamEncoding = NULL; - } - if (_Py_StandardStreamErrors) { - PyMem_RawFree(_Py_StandardStreamErrors); - _Py_StandardStreamErrors = NULL; - } - PyMem_Free(pythonioencoding); - Py_XDECREF(bimod); - Py_XDECREF(iomod); - return status; -} /* Parse input from a file and execute it */ @@ -1317,7 +110,7 @@ PyRun_InteractiveLoopFlags(FILE *fp, const char *filename_str, PyCompilerFlags * err = -1; for (;;) { ret = PyRun_InteractiveOneObject(fp, filename, flags); - PRINT_TOTAL_REFS(); + _PY_DEBUG_PRINT_TOTAL_REFS(); if (ret == E_EOF) { err = 0; break; @@ -1472,7 +265,7 @@ PyRun_InteractiveOneFlags(FILE *fp, const char *filename_str, PyCompilerFlags *f static int maybe_pyc_file(FILE *fp, const char* filename, const char* ext, int closeit) { - if (strcmp(ext, ".pyc") == 0 || strcmp(ext, ".pyo") == 0) + if (strcmp(ext, ".pyc") == 0) return 1; /* Only look into the file if we are allowed to close it, since @@ -1511,7 +304,7 @@ set_main_loader(PyObject *d, const char *filename, const char *loader_name) { PyInterpreterState *interp; PyThreadState *tstate; - PyObject *filename_obj, *loader_type, *loader; + PyObject *filename_obj, *bootstrap, *loader_type = NULL, *loader; int result = 0; filename_obj = PyUnicode_DecodeFSDefault(filename); @@ -1520,7 +313,12 @@ set_main_loader(PyObject *d, const char *filename, const char *loader_name) /* Get current thread state and interpreter pointer */ tstate = PyThreadState_GET(); interp = tstate->interp; - loader_type = PyObject_GetAttrString(interp->importlib, loader_name); + bootstrap = PyObject_GetAttrString(interp->importlib, + "_bootstrap_external"); + if (bootstrap != NULL) { + loader_type = PyObject_GetAttrString(bootstrap, loader_name); + Py_DECREF(bootstrap); + } if (loader_type == NULL) { Py_DECREF(filename_obj); return -1; @@ -1578,9 +376,6 @@ PyRun_SimpleFileExFlags(FILE *fp, const char *filename, int closeit, fprintf(stderr, "python: Can't reopen .pyc file\n"); goto done; } - /* Turn on optimization if a .pyo file is given */ - if (strcmp(ext, ".pyo") == 0) - Py_OptimizeFlag = 1; if (set_main_loader(d, filename, "SourcelessFileLoader") < 0) { fprintf(stderr, "python: failed to set __main__.__loader__\n"); @@ -1724,7 +519,7 @@ print_error_text(PyObject *f, int offset, PyObject *text_obj) return; if (offset >= 0) { - if (offset > 0 && offset == strlen(text) && text[offset - 1] == '\n') + if (offset > 0 && (size_t)offset == strlen(text) && text[offset - 1] == '\n') offset--; for (;;) { nl = strchr(text, '\n'); @@ -2188,13 +983,17 @@ run_pyc_file(FILE *fp, const char *filename, PyObject *globals, magic = PyMarshal_ReadLongFromFile(fp); if (magic != PyImport_GetMagicNumber()) { - PyErr_SetString(PyExc_RuntimeError, - "Bad magic number in .pyc file"); + if (!PyErr_Occurred()) + PyErr_SetString(PyExc_RuntimeError, + "Bad magic number in .pyc file"); return NULL; } /* Skip mtime and size */ (void) PyMarshal_ReadLongFromFile(fp); (void) PyMarshal_ReadLongFromFile(fp); + if (PyErr_Occurred()) + return NULL; + v = PyMarshal_ReadLastObjectFromFile(fp); if (v == NULL || !PyCode_Check(v)) { Py_XDECREF(v); @@ -2582,276 +1381,6 @@ cleanup: } } -/* Print the current exception (if an exception is set) with its traceback, - * or display the current Python stack. - * - * Don't call PyErr_PrintEx() and the except hook, because Py_FatalError() is - * called on catastrophic cases. */ - -static void -_Py_PrintFatalError(int fd) -{ - PyObject *ferr, *res; - PyObject *exception, *v, *tb; - int has_tb; - PyThreadState *tstate; - - PyErr_Fetch(&exception, &v, &tb); - if (exception == NULL) { - /* No current exception */ - goto display_stack; - } - - ferr = _PySys_GetObjectId(&PyId_stderr); - if (ferr == NULL || ferr == Py_None) { - /* sys.stderr is not set yet or set to None, - no need to try to display the exception */ - goto display_stack; - } - - PyErr_NormalizeException(&exception, &v, &tb); - if (tb == NULL) { - tb = Py_None; - Py_INCREF(tb); - } - PyException_SetTraceback(v, tb); - if (exception == NULL) { - /* PyErr_NormalizeException() failed */ - goto display_stack; - } - - has_tb = (tb != NULL && tb != Py_None); - PyErr_Display(exception, v, tb); - Py_XDECREF(exception); - Py_XDECREF(v); - Py_XDECREF(tb); - - /* sys.stderr may be buffered: call sys.stderr.flush() */ - res = _PyObject_CallMethodId(ferr, &PyId_flush, ""); - if (res == NULL) - PyErr_Clear(); - else - Py_DECREF(res); - - if (has_tb) - return; - -display_stack: -#ifdef WITH_THREAD - /* PyGILState_GetThisThreadState() works even if the GIL was released */ - tstate = PyGILState_GetThisThreadState(); -#else - tstate = PyThreadState_GET(); -#endif - if (tstate == NULL) { - /* _Py_DumpTracebackThreads() requires the thread state to display - * frames */ - return; - } - - fputc('\n', stderr); - fflush(stderr); - - /* display the current Python stack */ - _Py_DumpTracebackThreads(fd, tstate->interp, tstate); -} - -/* Print fatal error message and abort */ - -void -Py_FatalError(const char *msg) -{ - const int fd = fileno(stderr); - static int reentrant = 0; -#ifdef MS_WINDOWS - size_t len; - WCHAR* buffer; - size_t i; -#endif - - if (reentrant) { - /* Py_FatalError() caused a second fatal error. - Example: flush_std_files() raises a recursion error. */ - goto exit; - } - reentrant = 1; - - fprintf(stderr, "Fatal Python error: %s\n", msg); - fflush(stderr); /* it helps in Windows debug build */ - - /* Print the exception (if an exception is set) with its traceback, - * or display the current Python stack. */ - _Py_PrintFatalError(fd); - - /* Flush sys.stdout and sys.stderr */ - flush_std_files(); - - /* The main purpose of faulthandler is to display the traceback. We already - * did our best to display it. So faulthandler can now be disabled. - * (Don't trigger it on abort().) */ - _PyFaulthandler_Fini(); - -#ifdef MS_WINDOWS - len = strlen(msg); - - /* Convert the message to wchar_t. This uses a simple one-to-one - conversion, assuming that the this error message actually uses ASCII - only. If this ceases to be true, we will have to convert. */ - buffer = alloca( (len+1) * (sizeof *buffer)); - for( i=0; i<=len; ++i) - buffer[i] = msg[i]; - OutputDebugStringW(L"Fatal Python error: "); - OutputDebugStringW(buffer); - OutputDebugStringW(L"\n"); -#endif /* MS_WINDOWS */ - -exit: -#if defined(MS_WINDOWS) && defined(_DEBUG) - DebugBreak(); -#endif - abort(); -} - -/* Clean up and exit */ - -#ifdef WITH_THREAD -#include "pythread.h" -#endif - -static void (*pyexitfunc)(void) = NULL; -/* For the atexit module. */ -void _Py_PyAtExit(void (*func)(void)) -{ - pyexitfunc = func; -} - -static void -call_py_exitfuncs(void) -{ - if (pyexitfunc == NULL) - return; - - (*pyexitfunc)(); - PyErr_Clear(); -} - -/* Wait until threading._shutdown completes, provided - the threading module was imported in the first place. - The shutdown routine will wait until all non-daemon - "threading" threads have completed. */ -static void -wait_for_thread_shutdown(void) -{ -#ifdef WITH_THREAD - _Py_IDENTIFIER(_shutdown); - PyObject *result; - PyThreadState *tstate = PyThreadState_GET(); - PyObject *threading = PyMapping_GetItemString(tstate->interp->modules, - "threading"); - if (threading == NULL) { - /* threading not imported */ - PyErr_Clear(); - return; - } - result = _PyObject_CallMethodId(threading, &PyId__shutdown, ""); - if (result == NULL) { - PyErr_WriteUnraisable(threading); - } - else { - Py_DECREF(result); - } - Py_DECREF(threading); -#endif -} - -#define NEXITFUNCS 32 -static void (*exitfuncs[NEXITFUNCS])(void); -static int nexitfuncs = 0; - -int Py_AtExit(void (*func)(void)) -{ - if (nexitfuncs >= NEXITFUNCS) - return -1; - exitfuncs[nexitfuncs++] = func; - return 0; -} - -static void -call_ll_exitfuncs(void) -{ - while (nexitfuncs > 0) - (*exitfuncs[--nexitfuncs])(); - - fflush(stdout); - fflush(stderr); -} - -void -Py_Exit(int sts) -{ - Py_Finalize(); - - exit(sts); -} - -static void -initsigs(void) -{ -#ifdef SIGPIPE - PyOS_setsig(SIGPIPE, SIG_IGN); -#endif -#ifdef SIGXFZ - PyOS_setsig(SIGXFZ, SIG_IGN); -#endif -#ifdef SIGXFSZ - PyOS_setsig(SIGXFSZ, SIG_IGN); -#endif - PyOS_InitInterrupts(); /* May imply initsignal() */ - if (PyErr_Occurred()) { - Py_FatalError("Py_Initialize: can't import signal"); - } -} - - -/* Restore signals that the interpreter has called SIG_IGN on to SIG_DFL. - * - * All of the code in this function must only use async-signal-safe functions, - * listed at `man 7 signal` or - * http://www.opengroup.org/onlinepubs/009695399/functions/xsh_chap02_04.html. - */ -void -_Py_RestoreSignals(void) -{ -#ifdef SIGPIPE - PyOS_setsig(SIGPIPE, SIG_DFL); -#endif -#ifdef SIGXFZ - PyOS_setsig(SIGXFZ, SIG_DFL); -#endif -#ifdef SIGXFSZ - PyOS_setsig(SIGXFSZ, SIG_DFL); -#endif -} - - -/* - * The file descriptor fd is considered ``interactive'' if either - * a) isatty(fd) is TRUE, or - * b) the -i flag was given, and the filename associated with - * the descriptor is NULL or "<stdin>" or "???". - */ -int -Py_FdIsInteractive(FILE *fp, const char *filename) -{ - if (isatty((int)fileno(fp))) - return 1; - if (!Py_InteractiveFlag) - return 0; - return (filename == NULL) || - (strcmp(filename, "<stdin>") == 0) || - (strcmp(filename, "???") == 0); -} - #if defined(USE_STACKCHECK) #if defined(WIN32) && defined(_MSC_VER) @@ -2890,73 +1419,6 @@ PyOS_CheckStack(void) #endif /* USE_STACKCHECK */ - -/* Wrappers around sigaction() or signal(). */ - -PyOS_sighandler_t -PyOS_getsig(int sig) -{ -#ifdef HAVE_SIGACTION - struct sigaction context; - if (sigaction(sig, NULL, &context) == -1) - return SIG_ERR; - return context.sa_handler; -#else - PyOS_sighandler_t handler; -/* Special signal handling for the secure CRT in Visual Studio 2005 */ -#if defined(_MSC_VER) && _MSC_VER >= 1400 - switch (sig) { - /* Only these signals are valid */ - case SIGINT: - case SIGILL: - case SIGFPE: - case SIGSEGV: - case SIGTERM: - case SIGBREAK: - case SIGABRT: - break; - /* Don't call signal() with other values or it will assert */ - default: - return SIG_ERR; - } -#endif /* _MSC_VER && _MSC_VER >= 1400 */ - handler = signal(sig, SIG_IGN); - if (handler != SIG_ERR) - signal(sig, handler); - return handler; -#endif -} - -/* - * All of the code in this function must only use async-signal-safe functions, - * listed at `man 7 signal` or - * http://www.opengroup.org/onlinepubs/009695399/functions/xsh_chap02_04.html. - */ -PyOS_sighandler_t -PyOS_setsig(int sig, PyOS_sighandler_t handler) -{ -#ifdef HAVE_SIGACTION - /* Some code in Modules/signalmodule.c depends on sigaction() being - * used here if HAVE_SIGACTION is defined. Fix that if this code - * changes to invalidate that assumption. - */ - struct sigaction context, ocontext; - context.sa_handler = handler; - sigemptyset(&context.sa_mask); - context.sa_flags = 0; - if (sigaction(sig, &context, &ocontext) == -1) - return SIG_ERR; - return ocontext.sa_handler; -#else - PyOS_sighandler_t oldhandler; - oldhandler = signal(sig, handler); -#ifdef HAVE_SIGINTERRUPT - siginterrupt(sig, 1); -#endif - return oldhandler; -#endif -} - /* Deprecated C API functions still provided for binary compatiblity */ #undef PyParser_SimpleParseFile diff --git a/Python/pytime.c b/Python/pytime.c index de6a41fe00..7f65824b47 100644 --- a/Python/pytime.c +++ b/Python/pytime.c @@ -3,115 +3,25 @@ #include <windows.h> #endif -#if defined(__APPLE__) && defined(HAVE_GETTIMEOFDAY) && defined(HAVE_FTIME) - /* - * _PyTime_gettimeofday falls back to ftime when getttimeofday fails because the latter - * might fail on some platforms. This fallback is unwanted on MacOSX because - * that makes it impossible to use a binary build on OSX 10.4 on earlier - * releases of the OS. Therefore claim we don't support ftime. - */ -# undef HAVE_FTIME +#if defined(__APPLE__) +#include <mach/mach_time.h> /* mach_absolute_time(), mach_timebase_info() */ #endif -#if defined(HAVE_FTIME) && !defined(MS_WINDOWS) -#include <sys/timeb.h> -extern int ftime(struct timeb *); -#endif +/* To millisecond (10^-3) */ +#define SEC_TO_MS 1000 -static void -pygettimeofday(_PyTime_timeval *tp, _Py_clock_info_t *info) -{ -#ifdef MS_WINDOWS - FILETIME system_time; - ULARGE_INTEGER large; - ULONGLONG microseconds; +/* To microseconds (10^-6) */ +#define MS_TO_US 1000 +#define SEC_TO_US (SEC_TO_MS * MS_TO_US) - GetSystemTimeAsFileTime(&system_time); - large.u.LowPart = system_time.dwLowDateTime; - large.u.HighPart = system_time.dwHighDateTime; - /* 11,644,473,600,000,000: number of microseconds between - the 1st january 1601 and the 1st january 1970 (369 years + 89 leap - days). */ - microseconds = large.QuadPart / 10 - 11644473600000000; - tp->tv_sec = microseconds / 1000000; - tp->tv_usec = microseconds % 1000000; - if (info) { - DWORD timeAdjustment, timeIncrement; - BOOL isTimeAdjustmentDisabled; +/* To nanoseconds (10^-9) */ +#define US_TO_NS 1000 +#define MS_TO_NS (MS_TO_US * US_TO_NS) +#define SEC_TO_NS (SEC_TO_MS * MS_TO_NS) - info->implementation = "GetSystemTimeAsFileTime()"; - info->monotonic = 0; - (void) GetSystemTimeAdjustment(&timeAdjustment, &timeIncrement, - &isTimeAdjustmentDisabled); - info->resolution = timeIncrement * 1e-7; - info->adjustable = 1; - } -#else - /* There are three ways to get the time: - (1) gettimeofday() -- resolution in microseconds - (2) ftime() -- resolution in milliseconds - (3) time() -- resolution in seconds - In all cases the return value in a timeval struct. - Since on some systems (e.g. SCO ODT 3.0) gettimeofday() may - fail, so we fall back on ftime() or time(). - Note: clock resolution does not imply clock accuracy! */ - -#ifdef HAVE_GETTIMEOFDAY - int err; -#ifdef GETTIMEOFDAY_NO_TZ - err = gettimeofday(tp); -#else - err = gettimeofday(tp, (struct timezone *)NULL); -#endif - if (err == 0) { - if (info) { - info->implementation = "gettimeofday()"; - info->resolution = 1e-6; - info->monotonic = 0; - info->adjustable = 1; - } - return; - } -#endif /* HAVE_GETTIMEOFDAY */ - -#if defined(HAVE_FTIME) - { - struct timeb t; - ftime(&t); - tp->tv_sec = t.time; - tp->tv_usec = t.millitm * 1000; - if (info) { - info->implementation = "ftime()"; - info->resolution = 1e-3; - info->monotonic = 0; - info->adjustable = 1; - } - } -#else /* !HAVE_FTIME */ - tp->tv_sec = time(NULL); - tp->tv_usec = 0; - if (info) { - info->implementation = "time()"; - info->resolution = 1.0; - info->monotonic = 0; - info->adjustable = 1; - } -#endif /* !HAVE_FTIME */ - -#endif /* MS_WINDOWS */ -} - -void -_PyTime_gettimeofday(_PyTime_timeval *tp) -{ - pygettimeofday(tp, NULL); -} - -void -_PyTime_gettimeofday_info(_PyTime_timeval *tp, _Py_clock_info_t *info) -{ - pygettimeofday(tp, info); -} +/* Conversion from nanoseconds */ +#define NS_TO_MS (1000 * 1000) +#define NS_TO_US (1000) static void error_time_t_overflow(void) @@ -168,18 +78,16 @@ _PyTime_ObjectToDenominator(PyObject *obj, time_t *sec, long *numerator, } floatpart *= denominator; - if (round == _PyTime_ROUND_UP) { - if (intpart >= 0) { - floatpart = ceil(floatpart); - if (floatpart >= denominator) { - floatpart = 0.0; - intpart += 1.0; - } - } - else { - floatpart = floor(floatpart); + if (round == _PyTime_ROUND_CEILING) { + floatpart = ceil(floatpart); + if (floatpart >= denominator) { + floatpart = 0.0; + intpart += 1.0; } } + else { + floatpart = floor(floatpart); + } *sec = (time_t)intpart; err = intpart - (double)*sec; @@ -207,12 +115,10 @@ _PyTime_ObjectToTime_t(PyObject *obj, time_t *sec, _PyTime_round_t round) double d, intpart, err; d = PyFloat_AsDouble(obj); - if (round == _PyTime_ROUND_UP) { - if (d >= 0) - d = ceil(d); - else - d = floor(d); - } + if (round == _PyTime_ROUND_CEILING) + d = ceil(d); + else + d = floor(d); (void)modf(d, &intpart); *sec = (time_t)intpart; @@ -245,8 +151,546 @@ _PyTime_ObjectToTimeval(PyObject *obj, time_t *sec, long *usec, return _PyTime_ObjectToDenominator(obj, sec, usec, 1e6, round); } -void -_PyTime_Init() +static void +_PyTime_overflow(void) +{ + PyErr_SetString(PyExc_OverflowError, + "timestamp too large to convert to C _PyTime_t"); +} + +_PyTime_t +_PyTime_FromSeconds(int seconds) +{ + _PyTime_t t; + /* ensure that integer overflow cannot happen, int type should have 32 + bits, whereas _PyTime_t type has at least 64 bits (SEC_TO_MS takes 30 + bits). */ + assert((seconds >= 0 && seconds <= _PyTime_MAX / SEC_TO_NS) + || (seconds < 0 && seconds >= _PyTime_MIN / SEC_TO_NS)); + t = (_PyTime_t)seconds * SEC_TO_NS; + return t; +} + +_PyTime_t +_PyTime_FromNanoseconds(PY_LONG_LONG ns) +{ + _PyTime_t t; + assert(sizeof(PY_LONG_LONG) <= sizeof(_PyTime_t)); + t = Py_SAFE_DOWNCAST(ns, PY_LONG_LONG, _PyTime_t); + return t; +} + +#ifdef HAVE_CLOCK_GETTIME +static int +_PyTime_FromTimespec(_PyTime_t *tp, struct timespec *ts, int raise) +{ + _PyTime_t t; + int res = 0; + + t = (_PyTime_t)ts->tv_sec * SEC_TO_NS; + if (t / SEC_TO_NS != ts->tv_sec) { + if (raise) + _PyTime_overflow(); + res = -1; + } + + t += ts->tv_nsec; + + *tp = t; + return res; +} +#elif !defined(MS_WINDOWS) +static int +_PyTime_FromTimeval(_PyTime_t *tp, struct timeval *tv, int raise) +{ + _PyTime_t t; + int res = 0; + + t = (_PyTime_t)tv->tv_sec * SEC_TO_NS; + if (t / SEC_TO_NS != tv->tv_sec) { + if (raise) + _PyTime_overflow(); + res = -1; + } + + t += (_PyTime_t)tv->tv_usec * US_TO_NS; + + *tp = t; + return res; +} +#endif + +static int +_PyTime_FromObject(_PyTime_t *t, PyObject *obj, _PyTime_round_t round, + long to_nanoseconds) +{ + if (PyFloat_Check(obj)) { + /* volatile avoids unsafe optimization on float enabled by gcc -O3 */ + volatile double d, err; + + /* convert to a number of nanoseconds */ + d = PyFloat_AsDouble(obj); + d *= to_nanoseconds; + + if (round == _PyTime_ROUND_CEILING) + d = ceil(d); + else + d = floor(d); + + *t = (_PyTime_t)d; + err = d - (double)*t; + if (fabs(err) >= 1.0) { + _PyTime_overflow(); + return -1; + } + return 0; + } + else { +#ifdef HAVE_LONG_LONG + PY_LONG_LONG sec; + sec = PyLong_AsLongLong(obj); + assert(sizeof(PY_LONG_LONG) <= sizeof(_PyTime_t)); +#else + long sec; + sec = PyLong_AsLong(obj); + assert(sizeof(PY_LONG_LONG) <= sizeof(_PyTime_t)); +#endif + if (sec == -1 && PyErr_Occurred()) { + if (PyErr_ExceptionMatches(PyExc_OverflowError)) + _PyTime_overflow(); + return -1; + } + *t = sec * to_nanoseconds; + if (*t / to_nanoseconds != sec) { + _PyTime_overflow(); + return -1; + } + return 0; + } +} + +int +_PyTime_FromSecondsObject(_PyTime_t *t, PyObject *obj, _PyTime_round_t round) +{ + return _PyTime_FromObject(t, obj, round, SEC_TO_NS); +} + +int +_PyTime_FromMillisecondsObject(_PyTime_t *t, PyObject *obj, _PyTime_round_t round) +{ + return _PyTime_FromObject(t, obj, round, MS_TO_NS); +} + +double +_PyTime_AsSecondsDouble(_PyTime_t t) +{ + _PyTime_t sec, ns; + /* Divide using integers to avoid rounding issues on the integer part. + 1e-9 cannot be stored exactly in IEEE 64-bit. */ + sec = t / SEC_TO_NS; + ns = t % SEC_TO_NS; + return (double)sec + (double)ns * 1e-9; +} + +PyObject * +_PyTime_AsNanosecondsObject(_PyTime_t t) +{ +#ifdef HAVE_LONG_LONG + assert(sizeof(PY_LONG_LONG) >= sizeof(_PyTime_t)); + return PyLong_FromLongLong((PY_LONG_LONG)t); +#else + assert(sizeof(long) >= sizeof(_PyTime_t)); + return PyLong_FromLong((long)t); +#endif +} + +static _PyTime_t +_PyTime_Divide(const _PyTime_t t, const _PyTime_t k, + const _PyTime_round_t round) +{ + assert(k > 1); + if (round == _PyTime_ROUND_CEILING) { + if (t >= 0) + return (t + k - 1) / k; + else + return t / k; + } + else { + if (t >= 0) + return t / k; + else + return (t - (k - 1)) / k; + } +} + +_PyTime_t +_PyTime_AsMilliseconds(_PyTime_t t, _PyTime_round_t round) +{ + return _PyTime_Divide(t, NS_TO_MS, round); +} + +_PyTime_t +_PyTime_AsMicroseconds(_PyTime_t t, _PyTime_round_t round) +{ + return _PyTime_Divide(t, NS_TO_US, round); +} + +static int +_PyTime_AsTimeval_impl(_PyTime_t t, _PyTime_t *p_secs, int *p_us, + _PyTime_round_t round) +{ + _PyTime_t secs, ns; + int usec; + int res = 0; + + secs = t / SEC_TO_NS; + ns = t % SEC_TO_NS; + + usec = (int)_PyTime_Divide(ns, US_TO_NS, round); + if (usec < 0) { + usec += SEC_TO_US; + if (secs != _PyTime_MIN) + secs -= 1; + else + res = -1; + } + else if (usec >= SEC_TO_US) { + usec -= SEC_TO_US; + if (secs != _PyTime_MAX) + secs += 1; + else + res = -1; + } + assert(0 <= usec && usec < SEC_TO_US); + + *p_secs = secs; + *p_us = usec; + + return res; +} + +static int +_PyTime_AsTimevalStruct_impl(_PyTime_t t, struct timeval *tv, + _PyTime_round_t round, int raise) +{ + _PyTime_t secs; + int us; + int res; + + res = _PyTime_AsTimeval_impl(t, &secs, &us, round); + +#ifdef MS_WINDOWS + tv->tv_sec = (long)secs; +#else + tv->tv_sec = secs; +#endif + tv->tv_usec = us; + + if (res < 0 || (_PyTime_t)tv->tv_sec != secs) { + if (raise) + error_time_t_overflow(); + return -1; + } + return 0; +} + +int +_PyTime_AsTimeval(_PyTime_t t, struct timeval *tv, _PyTime_round_t round) { - /* Do nothing. Needed to force linking. */ + return _PyTime_AsTimevalStruct_impl(t, tv, round, 1); +} + +int +_PyTime_AsTimeval_noraise(_PyTime_t t, struct timeval *tv, _PyTime_round_t round) +{ + return _PyTime_AsTimevalStruct_impl(t, tv, round, 0); +} + +int +_PyTime_AsTimevalTime_t(_PyTime_t t, time_t *p_secs, int *us, + _PyTime_round_t round) +{ + _PyTime_t secs; + int res; + + res = _PyTime_AsTimeval_impl(t, &secs, us, round); + + *p_secs = secs; + + if (res < 0 || (_PyTime_t)*p_secs != secs) { + error_time_t_overflow(); + return -1; + } + return 0; +} + +#if defined(HAVE_CLOCK_GETTIME) || defined(HAVE_KQUEUE) +int +_PyTime_AsTimespec(_PyTime_t t, struct timespec *ts) +{ + _PyTime_t secs, nsec; + + secs = t / SEC_TO_NS; + nsec = t % SEC_TO_NS; + if (nsec < 0) { + nsec += SEC_TO_NS; + secs -= 1; + } + ts->tv_sec = (time_t)secs; + if ((_PyTime_t)ts->tv_sec != secs) { + _PyTime_overflow(); + return -1; + } + ts->tv_nsec = nsec; + + assert(0 <= ts->tv_nsec && ts->tv_nsec <= 999999999); + return 0; +} +#endif + +static int +pygettimeofday(_PyTime_t *tp, _Py_clock_info_t *info, int raise) +{ +#ifdef MS_WINDOWS + FILETIME system_time; + ULARGE_INTEGER large; + + assert(info == NULL || raise); + + GetSystemTimeAsFileTime(&system_time); + large.u.LowPart = system_time.dwLowDateTime; + large.u.HighPart = system_time.dwHighDateTime; + /* 11,644,473,600,000,000,000: number of nanoseconds between + the 1st january 1601 and the 1st january 1970 (369 years + 89 leap + days). */ + *tp = large.QuadPart * 100 - 11644473600000000000; + if (info) { + DWORD timeAdjustment, timeIncrement; + BOOL isTimeAdjustmentDisabled, ok; + + info->implementation = "GetSystemTimeAsFileTime()"; + info->monotonic = 0; + ok = GetSystemTimeAdjustment(&timeAdjustment, &timeIncrement, + &isTimeAdjustmentDisabled); + if (!ok) { + PyErr_SetFromWindowsErr(0); + return -1; + } + info->resolution = timeIncrement * 1e-7; + info->adjustable = 1; + } + +#else /* MS_WINDOWS */ + int err; +#ifdef HAVE_CLOCK_GETTIME + struct timespec ts; +#else + struct timeval tv; +#endif + + assert(info == NULL || raise); + +#ifdef HAVE_CLOCK_GETTIME + err = clock_gettime(CLOCK_REALTIME, &ts); + if (err) { + if (raise) + PyErr_SetFromErrno(PyExc_OSError); + return -1; + } + if (_PyTime_FromTimespec(tp, &ts, raise) < 0) + return -1; + + if (info) { + struct timespec res; + info->implementation = "clock_gettime(CLOCK_REALTIME)"; + info->monotonic = 0; + info->adjustable = 1; + if (clock_getres(CLOCK_REALTIME, &res) == 0) + info->resolution = res.tv_sec + res.tv_nsec * 1e-9; + else + info->resolution = 1e-9; + } +#else /* HAVE_CLOCK_GETTIME */ + + /* test gettimeofday() */ +#ifdef GETTIMEOFDAY_NO_TZ + err = gettimeofday(&tv); +#else + err = gettimeofday(&tv, (struct timezone *)NULL); +#endif + if (err) { + if (raise) + PyErr_SetFromErrno(PyExc_OSError); + return -1; + } + if (_PyTime_FromTimeval(tp, &tv, raise) < 0) + return -1; + + if (info) { + info->implementation = "gettimeofday()"; + info->resolution = 1e-6; + info->monotonic = 0; + info->adjustable = 1; + } +#endif /* !HAVE_CLOCK_GETTIME */ +#endif /* !MS_WINDOWS */ + return 0; +} + +_PyTime_t +_PyTime_GetSystemClock(void) +{ + _PyTime_t t; + if (pygettimeofday(&t, NULL, 0) < 0) { + /* should not happen, _PyTime_Init() checked the clock at startup */ + assert(0); + + /* use a fixed value instead of a random value from the stack */ + t = 0; + } + return t; +} + +int +_PyTime_GetSystemClockWithInfo(_PyTime_t *t, _Py_clock_info_t *info) +{ + return pygettimeofday(t, info, 1); +} + + +static int +pymonotonic(_PyTime_t *tp, _Py_clock_info_t *info, int raise) +{ +#if defined(MS_WINDOWS) + ULONGLONG result; + + assert(info == NULL || raise); + + result = GetTickCount64(); + + *tp = result * MS_TO_NS; + if (*tp / MS_TO_NS != result) { + if (raise) { + _PyTime_overflow(); + return -1; + } + /* Hello, time traveler! */ + assert(0); + } + + if (info) { + DWORD timeAdjustment, timeIncrement; + BOOL isTimeAdjustmentDisabled, ok; + info->implementation = "GetTickCount64()"; + info->monotonic = 1; + ok = GetSystemTimeAdjustment(&timeAdjustment, &timeIncrement, + &isTimeAdjustmentDisabled); + if (!ok) { + PyErr_SetFromWindowsErr(0); + return -1; + } + info->resolution = timeIncrement * 1e-7; + info->adjustable = 0; + } + +#elif defined(__APPLE__) + static mach_timebase_info_data_t timebase; + uint64_t time; + + if (timebase.denom == 0) { + /* According to the Technical Q&A QA1398, mach_timebase_info() cannot + fail: https://developer.apple.com/library/mac/#qa/qa1398/ */ + (void)mach_timebase_info(&timebase); + } + + time = mach_absolute_time(); + + /* apply timebase factor */ + time *= timebase.numer; + time /= timebase.denom; + + *tp = time; + + if (info) { + info->implementation = "mach_absolute_time()"; + info->resolution = (double)timebase.numer / timebase.denom * 1e-9; + info->monotonic = 1; + info->adjustable = 0; + } + +#else + struct timespec ts; +#ifdef CLOCK_HIGHRES + const clockid_t clk_id = CLOCK_HIGHRES; + const char *implementation = "clock_gettime(CLOCK_HIGHRES)"; +#else + const clockid_t clk_id = CLOCK_MONOTONIC; + const char *implementation = "clock_gettime(CLOCK_MONOTONIC)"; +#endif + + assert(info == NULL || raise); + + if (clock_gettime(clk_id, &ts) != 0) { + if (raise) { + PyErr_SetFromErrno(PyExc_OSError); + return -1; + } + return -1; + } + + if (info) { + struct timespec res; + info->monotonic = 1; + info->implementation = implementation; + info->adjustable = 0; + if (clock_getres(clk_id, &res) != 0) { + PyErr_SetFromErrno(PyExc_OSError); + return -1; + } + info->resolution = res.tv_sec + res.tv_nsec * 1e-9; + } + if (_PyTime_FromTimespec(tp, &ts, raise) < 0) + return -1; +#endif + return 0; +} + +_PyTime_t +_PyTime_GetMonotonicClock(void) +{ + _PyTime_t t; + if (pymonotonic(&t, NULL, 0) < 0) { + /* should not happen, _PyTime_Init() checked that monotonic clock at + startup */ + assert(0); + + /* use a fixed value instead of a random value from the stack */ + t = 0; + } + return t; +} + +int +_PyTime_GetMonotonicClockWithInfo(_PyTime_t *tp, _Py_clock_info_t *info) +{ + return pymonotonic(tp, info, 1); +} + +int +_PyTime_Init(void) +{ + _PyTime_t t; + + /* ensure that the system clock works */ + if (_PyTime_GetSystemClockWithInfo(&t, NULL) < 0) + return -1; + + /* ensure that the operating system provides a monotonic clock */ + if (_PyTime_GetMonotonicClockWithInfo(&t, NULL) < 0) + return -1; + + /* check that _PyTime_FromSeconds() cannot overflow */ + assert(INT_MAX <= _PyTime_MAX / SEC_TO_NS); + assert(INT_MIN >= _PyTime_MIN / SEC_TO_NS); + return 0; } diff --git a/Python/random.c b/Python/random.c index af3d0bd0d5..772bfef0e8 100644 --- a/Python/random.c +++ b/Python/random.c @@ -1,11 +1,16 @@ #include "Python.h" #ifdef MS_WINDOWS -#include <windows.h> +# include <windows.h> #else -#include <fcntl.h> -#ifdef HAVE_SYS_STAT_H -#include <sys/stat.h> -#endif +# include <fcntl.h> +# ifdef HAVE_SYS_STAT_H +# include <sys/stat.h> +# endif +# ifdef HAVE_GETRANDOM +# include <sys/random.h> +# elif defined(HAVE_GETRANDOM_SYSCALL) +# include <sys/syscall.h> +# endif #endif #ifdef Py_DEBUG @@ -67,8 +72,6 @@ win32_urandom(unsigned char *buffer, Py_ssize_t size, int raise) return 0; } -/* Issue #25003: Don' use getentropy() on Solaris (available since - * Solaris 11.3), it is blocking whereas os.urandom() should not block. */ #elif defined(HAVE_GETENTROPY) && !defined(sun) #define PY_GETENTROPY 1 @@ -107,12 +110,89 @@ py_getentropy(unsigned char *buffer, Py_ssize_t size, int fatal) } #else + +/* Issue #25003: Don' use getentropy() on Solaris (available since + * Solaris 11.3), it is blocking whereas os.urandom() should not block. */ +#if defined(HAVE_GETRANDOM) || defined(HAVE_GETRANDOM_SYSCALL) +#define PY_GETRANDOM 1 + +static int +py_getrandom(void *buffer, Py_ssize_t size, int raise) +{ + /* Is getrandom() supported by the running kernel? + * Need Linux kernel 3.17 or newer, or Solaris 11.3 or newer */ + static int getrandom_works = 1; + /* Use non-blocking /dev/urandom device. On Linux at boot, the getrandom() + * syscall blocks until /dev/urandom is initialized with enough entropy. */ + const int flags = 0; + int n; + + if (!getrandom_works) + return 0; + + while (0 < size) { + errno = 0; + +#ifdef HAVE_GETRANDOM + if (raise) { + Py_BEGIN_ALLOW_THREADS + n = getrandom(buffer, size, flags); + Py_END_ALLOW_THREADS + } + else { + n = getrandom(buffer, size, flags); + } +#else + /* On Linux, use the syscall() function because the GNU libc doesn't + * expose the Linux getrandom() syscall yet. See: + * https://sourceware.org/bugzilla/show_bug.cgi?id=17252 */ + if (raise) { + Py_BEGIN_ALLOW_THREADS + n = syscall(SYS_getrandom, buffer, size, flags); + Py_END_ALLOW_THREADS + } + else { + n = syscall(SYS_getrandom, buffer, size, flags); + } +#endif + + if (n < 0) { + if (errno == ENOSYS) { + getrandom_works = 0; + return 0; + } + + if (errno == EINTR) { + if (PyErr_CheckSignals()) { + if (!raise) + Py_FatalError("getrandom() interrupted by a signal"); + return -1; + } + /* retry getrandom() */ + continue; + } + + if (raise) + PyErr_SetFromErrno(PyExc_OSError); + else + Py_FatalError("getrandom() failed"); + return -1; + } + + buffer += n; + size -= n; + } + return 1; +} +#endif + static struct { int fd; dev_t st_dev; ino_t st_ino; } urandom_cache = { -1 }; + /* Read size bytes from /dev/urandom into buffer. Call Py_FatalError() on error. */ static void @@ -123,7 +203,14 @@ dev_urandom_noraise(unsigned char *buffer, Py_ssize_t size) assert (0 < size); - fd = _Py_open("/dev/urandom", O_RDONLY); +#ifdef PY_GETRANDOM + if (py_getrandom(buffer, size, 0) == 1) + return; + /* getrandom() is not supported by the running kernel, fall back + * on reading /dev/urandom */ +#endif + + fd = _Py_open_noraise("/dev/urandom", O_RDONLY); if (fd < 0) Py_FatalError("Failed to open /dev/urandom"); @@ -151,14 +238,27 @@ dev_urandom_python(char *buffer, Py_ssize_t size) { int fd; Py_ssize_t n; - struct stat st; + struct _Py_stat_struct st; +#ifdef PY_GETRANDOM + int res; +#endif if (size <= 0) return 0; +#ifdef PY_GETRANDOM + res = py_getrandom(buffer, size, 1); + if (res < 0) + return -1; + if (res == 1) + return 0; + /* getrandom() is not supported by the running kernel, fall back + * on reading /dev/urandom */ +#endif + if (urandom_cache.fd >= 0) { /* Does the fd point to the same thing as before? (issue #21207) */ - if (fstat(urandom_cache.fd, &st) + if (_Py_fstat_noraise(urandom_cache.fd, &st) || st.st_dev != urandom_cache.st_dev || st.st_ino != urandom_cache.st_ino) { /* Something changed: forget the cached fd (but don't close it, @@ -170,17 +270,13 @@ dev_urandom_python(char *buffer, Py_ssize_t size) if (urandom_cache.fd >= 0) fd = urandom_cache.fd; else { - Py_BEGIN_ALLOW_THREADS fd = _Py_open("/dev/urandom", O_RDONLY); - Py_END_ALLOW_THREADS - if (fd < 0) - { + if (fd < 0) { if (errno == ENOENT || errno == ENXIO || errno == ENODEV || errno == EACCES) PyErr_SetString(PyExc_NotImplementedError, "/dev/urandom (or equivalent) not found"); - else - PyErr_SetFromErrno(PyExc_OSError); + /* otherwise, keep the OSError exception raised by _Py_open() */ return -1; } if (urandom_cache.fd >= 0) { @@ -190,8 +286,7 @@ dev_urandom_python(char *buffer, Py_ssize_t size) fd = urandom_cache.fd; } else { - if (fstat(fd, &st)) { - PyErr_SetFromErrno(PyExc_OSError); + if (_Py_fstat(fd, &st)) { close(fd); return -1; } @@ -203,29 +298,21 @@ dev_urandom_python(char *buffer, Py_ssize_t size) } } - Py_BEGIN_ALLOW_THREADS do { - do { - n = read(fd, buffer, (size_t)size); - } while (n < 0 && errno == EINTR); - if (n <= 0) - break; + n = _Py_read(fd, buffer, (size_t)size); + if (n == -1) + return -1; + if (n == 0) { + PyErr_Format(PyExc_RuntimeError, + "Failed to read %zi bytes from /dev/urandom", + size); + return -1; + } + buffer += n; - size -= (Py_ssize_t)n; + size -= n; } while (0 < size); - Py_END_ALLOW_THREADS - if (n <= 0) - { - /* stop on error or if read(size) returned 0 */ - if (n < 0) - PyErr_SetFromErrno(PyExc_OSError); - else - PyErr_Format(PyExc_RuntimeError, - "Failed to read %zi bytes from /dev/urandom", - size); - return -1; - } return 0; } @@ -238,7 +325,7 @@ dev_urandom_close(void) } } -#endif /* HAVE_GETENTROPY */ +#endif /* Fill buffer with pseudo-random bytes generated by a linear congruent generator (LCG): diff --git a/Python/symtable.c b/Python/symtable.c index 951267342b..64910d8a55 100644 --- a/Python/symtable.c +++ b/Python/symtable.c @@ -47,7 +47,6 @@ ste_new(struct symtable *st, identifier name, _Py_block_ty block, ste->ste_directives = NULL; ste->ste_type = block; - ste->ste_unoptimized = 0; ste->ste_nested = 0; ste->ste_free = 0; ste->ste_varargs = 0; @@ -113,7 +112,6 @@ static PyMemberDef ste_memberlist[] = { {"symbols", T_OBJECT, OFF(ste_symbols), READONLY}, {"varnames", T_OBJECT, OFF(ste_varnames), READONLY}, {"children", T_OBJECT, OFF(ste_children), READONLY}, - {"optimized",T_INT, OFF(ste_unoptimized), READONLY}, {"nested", T_INT, OFF(ste_nested), READONLY}, {"type", T_INT, OFF(ste_type), READONLY}, {"lineno", T_INT, OFF(ste_lineno), READONLY}, @@ -182,7 +180,7 @@ static int symtable_visit_slice(struct symtable *st, slice_ty); static int symtable_visit_params(struct symtable *st, asdl_seq *args); static int symtable_visit_argannotations(struct symtable *st, asdl_seq *args); static int symtable_implicit_arg(struct symtable *st, int pos); -static int symtable_visit_annotations(struct symtable *st, stmt_ty s); +static int symtable_visit_annotations(struct symtable *st, stmt_ty s, arguments_ty, expr_ty); static int symtable_visit_withitem(struct symtable *st, withitem_ty item); @@ -271,7 +269,6 @@ PySymtable_BuildObject(mod_ty mod, PyObject *filename, PyFutureFeatures *future) } st->st_top = st->st_cur; - st->st_cur->ste_unoptimized = OPT_TOPLEVEL; switch (mod->kind) { case Module_kind: seq = mod->v.Module.body; @@ -1086,13 +1083,13 @@ error: } \ } -#define VISIT_KWONLYDEFAULTS(ST, KW_DEFAULTS) { \ +#define VISIT_SEQ_WITH_NULL(ST, TYPE, SEQ) { \ int i = 0; \ - asdl_seq *seq = (KW_DEFAULTS); /* avoid variable capture */ \ + asdl_seq *seq = (SEQ); /* avoid variable capture */ \ for (i = 0; i < asdl_seq_LEN(seq); i++) { \ - expr_ty elt = (expr_ty)asdl_seq_GET(seq, i); \ + TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, i); \ if (!elt) continue; /* can be NULL */ \ - if (!symtable_visit_expr((ST), elt)) \ + if (!symtable_visit_ ## TYPE((ST), elt)) \ VISIT_QUIT((ST), 0); \ } \ } @@ -1138,7 +1135,7 @@ static int symtable_visit_stmt(struct symtable *st, stmt_ty s) { if (++st->recursion_depth > st->recursion_limit) { - PyErr_SetString(PyExc_RuntimeError, + PyErr_SetString(PyExc_RecursionError, "maximum recursion depth exceeded during compilation"); VISIT_QUIT(st, 0); } @@ -1149,9 +1146,9 @@ symtable_visit_stmt(struct symtable *st, stmt_ty s) if (s->v.FunctionDef.args->defaults) VISIT_SEQ(st, expr, s->v.FunctionDef.args->defaults); if (s->v.FunctionDef.args->kw_defaults) - VISIT_KWONLYDEFAULTS(st, - s->v.FunctionDef.args->kw_defaults); - if (!symtable_visit_annotations(st, s)) + VISIT_SEQ_WITH_NULL(st, expr, s->v.FunctionDef.args->kw_defaults); + if (!symtable_visit_annotations(st, s, s->v.FunctionDef.args, + s->v.FunctionDef.returns)) VISIT_QUIT(st, 0); if (s->v.FunctionDef.decorator_list) VISIT_SEQ(st, expr, s->v.FunctionDef.decorator_list); @@ -1170,10 +1167,6 @@ symtable_visit_stmt(struct symtable *st, stmt_ty s) 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, @@ -1245,21 +1238,9 @@ symtable_visit_stmt(struct symtable *st, stmt_ty s) break; case Import_kind: VISIT_SEQ(st, alias, s->v.Import.names); - /* XXX Don't have the lineno available inside - visit_alias */ - if (st->st_cur->ste_unoptimized && !st->st_cur->ste_opt_lineno) { - st->st_cur->ste_opt_lineno = s->lineno; - st->st_cur->ste_opt_col_offset = s->col_offset; - } break; case ImportFrom_kind: VISIT_SEQ(st, alias, s->v.ImportFrom.names); - /* XXX Don't have the lineno available inside - visit_alias */ - if (st->st_cur->ste_unoptimized && !st->st_cur->ste_opt_lineno) { - st->st_cur->ste_opt_lineno = s->lineno; - st->st_cur->ste_opt_col_offset = s->col_offset; - } break; case Global_kind: { int i; @@ -1335,6 +1316,39 @@ symtable_visit_stmt(struct symtable *st, stmt_ty s) VISIT_SEQ(st, withitem, s->v.With.items); VISIT_SEQ(st, stmt, s->v.With.body); break; + case AsyncFunctionDef_kind: + if (!symtable_add_def(st, s->v.AsyncFunctionDef.name, DEF_LOCAL)) + VISIT_QUIT(st, 0); + if (s->v.AsyncFunctionDef.args->defaults) + VISIT_SEQ(st, expr, s->v.AsyncFunctionDef.args->defaults); + if (s->v.AsyncFunctionDef.args->kw_defaults) + VISIT_SEQ_WITH_NULL(st, expr, + s->v.AsyncFunctionDef.args->kw_defaults); + if (!symtable_visit_annotations(st, s, s->v.AsyncFunctionDef.args, + s->v.AsyncFunctionDef.returns)) + VISIT_QUIT(st, 0); + if (s->v.AsyncFunctionDef.decorator_list) + VISIT_SEQ(st, expr, s->v.AsyncFunctionDef.decorator_list); + if (!symtable_enter_block(st, s->v.AsyncFunctionDef.name, + FunctionBlock, (void *)s, s->lineno, + s->col_offset)) + VISIT_QUIT(st, 0); + VISIT(st, arguments, s->v.AsyncFunctionDef.args); + VISIT_SEQ(st, stmt, s->v.AsyncFunctionDef.body); + if (!symtable_exit_block(st, s)) + VISIT_QUIT(st, 0); + break; + case AsyncWith_kind: + VISIT_SEQ(st, withitem, s->v.AsyncWith.items); + VISIT_SEQ(st, stmt, s->v.AsyncWith.body); + break; + case AsyncFor_kind: + VISIT(st, expr, s->v.AsyncFor.target); + VISIT(st, expr, s->v.AsyncFor.iter); + VISIT_SEQ(st, stmt, s->v.AsyncFor.body); + if (s->v.AsyncFor.orelse) + VISIT_SEQ(st, stmt, s->v.AsyncFor.orelse); + break; } VISIT_QUIT(st, 1); } @@ -1343,7 +1357,7 @@ static int symtable_visit_expr(struct symtable *st, expr_ty e) { if (++st->recursion_depth > st->recursion_limit) { - PyErr_SetString(PyExc_RuntimeError, + PyErr_SetString(PyExc_RecursionError, "maximum recursion depth exceeded during compilation"); VISIT_QUIT(st, 0); } @@ -1364,8 +1378,7 @@ symtable_visit_expr(struct symtable *st, expr_ty e) 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); + VISIT_SEQ_WITH_NULL(st, expr, e->v.Lambda.args->kw_defaults); if (!symtable_enter_block(st, lambda, FunctionBlock, (void *)e, e->lineno, e->col_offset)) @@ -1382,7 +1395,7 @@ symtable_visit_expr(struct symtable *st, expr_ty e) VISIT(st, expr, e->v.IfExp.orelse); break; case Dict_kind: - VISIT_SEQ(st, expr, e->v.Dict.keys); + VISIT_SEQ_WITH_NULL(st, expr, e->v.Dict.keys); VISIT_SEQ(st, expr, e->v.Dict.values); break; case Set_kind: @@ -1413,6 +1426,10 @@ symtable_visit_expr(struct symtable *st, expr_ty e) VISIT(st, expr, e->v.YieldFrom.value); st->st_cur->ste_generator = 1; break; + case Await_kind: + VISIT(st, expr, e->v.Await.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); @@ -1420,11 +1437,7 @@ symtable_visit_expr(struct symtable *st, expr_ty e) 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); + VISIT_SEQ_WITH_NULL(st, keyword, e->v.Call.keywords); break; case Num_kind: case Str_kind: @@ -1517,10 +1530,9 @@ symtable_visit_argannotations(struct symtable *st, asdl_seq *args) } static int -symtable_visit_annotations(struct symtable *st, stmt_ty s) +symtable_visit_annotations(struct symtable *st, stmt_ty s, + arguments_ty a, expr_ty returns) { - arguments_ty a = s->v.FunctionDef.args; - if (a->args && !symtable_visit_argannotations(st, a->args)) return 0; if (a->vararg && a->vararg->annotation) @@ -1529,8 +1541,8 @@ symtable_visit_annotations(struct symtable *st, stmt_ty s) VISIT(st, expr, a->kwarg->annotation); if (a->kwonlyargs && !symtable_visit_argannotations(st, a->kwonlyargs)) return 0; - if (s->v.FunctionDef.returns) - VISIT(st, expr, s->v.FunctionDef.returns); + if (returns) + VISIT(st, expr, returns); return 1; } @@ -1615,7 +1627,6 @@ symtable_visit_alias(struct symtable *st, alias_ty a) Py_DECREF(store_name); return 0; } - st->st_cur->ste_unoptimized |= OPT_IMPORT_STAR; Py_DECREF(store_name); return 1; } diff --git a/Python/sysmodule.c b/Python/sysmodule.c index 290eec1199..334f5d0c8e 100644 --- a/Python/sysmodule.c +++ b/Python/sysmodule.c @@ -632,19 +632,84 @@ processor's time-stamp counter." static PyObject * sys_setrecursionlimit(PyObject *self, PyObject *args) { - int new_limit; + int new_limit, mark; + PyThreadState *tstate; + if (!PyArg_ParseTuple(args, "i:setrecursionlimit", &new_limit)) return NULL; - if (new_limit <= 0) { + + if (new_limit < 1) { PyErr_SetString(PyExc_ValueError, - "recursion limit must be positive"); + "recursion limit must be greater or equal than 1"); + return NULL; + } + + /* Issue #25274: When the recursion depth hits the recursion limit in + _Py_CheckRecursiveCall(), the overflowed flag of the thread state is + set to 1 and a RecursionError is raised. The overflowed flag is reset + to 0 when the recursion depth goes below the low-water mark: see + Py_LeaveRecursiveCall(). + + Reject too low new limit if the current recursion depth is higher than + the new low-water mark. Otherwise it may not be possible anymore to + reset the overflowed flag to 0. */ + mark = _Py_RecursionLimitLowerWaterMark(new_limit); + tstate = PyThreadState_GET(); + if (tstate->recursion_depth >= mark) { + PyErr_Format(PyExc_RecursionError, + "cannot set the recursion limit to %i at " + "the recursion depth %i: the limit is too low", + new_limit, tstate->recursion_depth); return NULL; } + Py_SetRecursionLimit(new_limit); Py_INCREF(Py_None); return Py_None; } +static PyObject * +sys_set_coroutine_wrapper(PyObject *self, PyObject *wrapper) +{ + if (wrapper != Py_None) { + if (!PyCallable_Check(wrapper)) { + PyErr_Format(PyExc_TypeError, + "callable expected, got %.50s", + Py_TYPE(wrapper)->tp_name); + return NULL; + } + _PyEval_SetCoroutineWrapper(wrapper); + } + else { + _PyEval_SetCoroutineWrapper(NULL); + } + Py_RETURN_NONE; +} + +PyDoc_STRVAR(set_coroutine_wrapper_doc, +"set_coroutine_wrapper(wrapper)\n\ +\n\ +Set a wrapper for coroutine objects." +); + +static PyObject * +sys_get_coroutine_wrapper(PyObject *self, PyObject *args) +{ + PyObject *wrapper = _PyEval_GetCoroutineWrapper(); + if (wrapper == NULL) { + wrapper = Py_None; + } + Py_INCREF(wrapper); + return wrapper; +} + +PyDoc_STRVAR(get_coroutine_wrapper_doc, +"get_coroutine_wrapper()\n\ +\n\ +Return the wrapper for coroutine objects set by sys.set_coroutine_wrapper." +); + + static PyTypeObject Hash_InfoType; PyDoc_STRVAR(hash_info_doc, @@ -772,6 +837,12 @@ static PyStructSequence_Desc windows_version_desc = { via indexing, the rest are name only */ }; +/* Disable deprecation warnings about GetVersionEx as the result is + being passed straight through to the caller, who is responsible for + using it correctly. */ +#pragma warning(push) +#pragma warning(disable:4996) + static PyObject * sys_getwindowsversion(PyObject *self) { @@ -803,6 +874,8 @@ sys_getwindowsversion(PyObject *self) return version; } +#pragma warning(pop) + #endif /* MS_WINDOWS */ #ifdef HAVE_DLOPEN @@ -1121,6 +1194,16 @@ PyDoc_STRVAR(sys_clear_type_cache__doc__, "_clear_type_cache() -> None\n\ Clear the internal type lookup cache."); +static PyObject * +sys_is_finalizing(PyObject* self, PyObject* args) +{ + return PyBool_FromLong(_Py_Finalizing != NULL); +} + +PyDoc_STRVAR(is_finalizing_doc, +"is_finalizing()\n\ +Return True if Python is exiting."); + static PyMethodDef sys_methods[] = { /* Might as well keep this in alphabetic order */ @@ -1167,6 +1250,7 @@ static PyMethodDef sys_methods[] = { getwindowsversion_doc}, #endif /* MS_WINDOWS */ {"intern", sys_intern, METH_VARARGS, intern_doc}, + {"is_finalizing", sys_is_finalizing, METH_NOARGS, is_finalizing_doc}, #ifdef USE_MALLOPT {"mdebug", sys_mdebug, METH_VARARGS}, #endif @@ -1196,6 +1280,10 @@ static PyMethodDef sys_methods[] = { {"call_tracing", sys_call_tracing, METH_VARARGS, call_tracing_doc}, {"_debugmallocstats", sys_debugmallocstats, METH_NOARGS, debugmallocstats_doc}, + {"set_coroutine_wrapper", sys_set_coroutine_wrapper, METH_O, + set_coroutine_wrapper_doc}, + {"get_coroutine_wrapper", sys_get_coroutine_wrapper, METH_NOARGS, + get_coroutine_wrapper_doc}, {NULL, NULL} /* sentinel */ }; @@ -1670,8 +1758,8 @@ _PySys_Init(void) the shell already prevents that. */ #if !defined(MS_WINDOWS) { - struct stat sb; - if (fstat(fileno(stdin), &sb) == 0 && + struct _Py_stat_struct sb; + if (_Py_fstat_noraise(fileno(stdin), &sb) == 0 && S_ISDIR(sb.st_mode)) { /* There's nothing more we can do. */ /* Py_FatalError() will core dump, so just exit. */ @@ -1681,7 +1769,7 @@ _PySys_Init(void) } #endif - /* stdin/stdout/stderr are now set by pythonrun.c */ + /* stdin/stdout/stderr are set in pylifecycle.c */ SET_SYS_FROM_STRING_BORROW("__displayhook__", PyDict_GetItemString(sysdict, "displayhook")); diff --git a/Python/thread.c b/Python/thread.c index 810691f0b0..63eeb1e123 100644 --- a/Python/thread.c +++ b/Python/thread.c @@ -431,7 +431,7 @@ PyThread_GetInfo(void) && defined(_CS_GNU_LIBPTHREAD_VERSION)) value = NULL; len = confstr(_CS_GNU_LIBPTHREAD_VERSION, buffer, sizeof(buffer)); - if (1 < len && len < sizeof(buffer)) { + if (1 < len && (size_t)len < sizeof(buffer)) { value = PyUnicode_DecodeFSDefaultAndSize(buffer, len-1); if (value == NULL) PyErr_Clear(); diff --git a/Python/thread_foobar.h b/Python/thread_foobar.h index d2b78c5cae..ea96f9c9d7 100644 --- a/Python/thread_foobar.h +++ b/Python/thread_foobar.h @@ -1,4 +1,3 @@ - /* * Initialization. */ @@ -61,10 +60,18 @@ PyThread_free_lock(PyThread_type_lock lock) int PyThread_acquire_lock(PyThread_type_lock lock, int waitflag) { + return PyThread_acquire_lock_timed(lock, waitflag ? -1 : 0, 0); +} + +PyLockStatus +PyThread_acquire_lock_timed(PyThread_type_lock lock, PY_TIMEOUT_T microseconds, + int intr_flag) +{ int success; - dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag)); - dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success)); + dprintf(("PyThread_acquire_lock_timed(%p, %lld, %d) called\n", lock, microseconds, intr_flag)); + dprintf(("PyThread_acquire_lock_timed(%p, %lld, %d) -> %d\n", + lock, microseconds, intr_flag, success)); return success; } @@ -73,3 +80,53 @@ PyThread_release_lock(PyThread_type_lock lock) { dprintf(("PyThread_release_lock(%p) called\n", lock)); } + +/* The following are only needed if native TLS support exists */ +#define Py_HAVE_NATIVE_TLS + +#ifdef Py_HAVE_NATIVE_TLS +int +PyThread_create_key(void) +{ + int result; + return result; +} + +void +PyThread_delete_key(int key) +{ + +} + +int +PyThread_set_key_value(int key, void *value) +{ + int ok; + + /* A failure in this case returns -1 */ + if (!ok) + return -1; + return 0; +} + +void * +PyThread_get_key_value(int key) +{ + void *result; + + return result; +} + +void +PyThread_delete_key_value(int key) +{ + +} + +void +PyThread_ReInitTLS(void) +{ + +} + +#endif diff --git a/Python/thread_pthread.h b/Python/thread_pthread.h index d9f7c76f2a..27e0dc84bc 100644 --- a/Python/thread_pthread.h +++ b/Python/thread_pthread.h @@ -608,7 +608,15 @@ PyThread_create_key(void) { pthread_key_t key; int fail = pthread_key_create(&key, NULL); - return fail ? -1 : key; + if (fail) + return -1; + if (key > INT_MAX) { + /* Issue #22206: handle integer overflow */ + pthread_key_delete(key); + errno = ENOMEM; + return -1; + } + return (int)key; } void diff --git a/Python/traceback.c b/Python/traceback.c index 7d1fc2e8ac..941d1cbbbb 100644 --- a/Python/traceback.c +++ b/Python/traceback.c @@ -13,7 +13,7 @@ #define OFF(x) offsetof(PyTracebackObject, x) -#define PUTS(fd, str) write(fd, str, (int)strlen(str)) +#define PUTS(fd, str) _Py_write_noraise(fd, str, (int)strlen(str)) #define MAX_STRING_LENGTH 500 #define MAX_FRAME_DEPTH 100 #define MAX_NTHREADS 100 @@ -231,7 +231,7 @@ _Py_FindSourceFile(PyObject *filename, char* namebuf, size_t namelen, PyObject * } strcpy(namebuf, PyBytes_AS_STRING(path)); Py_DECREF(path); - if (strlen(namebuf) != len) + if (strlen(namebuf) != (size_t)len) continue; /* v contains '\0' */ if (len > 0 && namebuf[len-1] != SEP) namebuf[len++] = SEP; @@ -512,7 +512,7 @@ dump_decimal(int fd, int value) len++; } while (value); reverse_string(buffer, len); - write(fd, buffer, len); + _Py_write_noraise(fd, buffer, len); } /* Format an integer in range [0; 0xffffffff] to hexadecimal of 'width' digits, @@ -532,7 +532,7 @@ dump_hexadecimal(int fd, unsigned long value, int width) len++; } while (len < width || value); reverse_string(buffer, len); - write(fd, buffer, len); + _Py_write_noraise(fd, buffer, len); } /* Write an unicode object into the file fd using ascii+backslashreplace. @@ -582,15 +582,16 @@ dump_ascii(int fd, PyObject *text) ch = PyUnicode_READ(kind, data, i); else ch = wstr[i]; - if (ch < 128) { + if (' ' <= ch && ch <= 126) { + /* printable ASCII character */ char c = (char)ch; - write(fd, &c, 1); + _Py_write_noraise(fd, &c, 1); } - else if (ch < 0xff) { + else if (ch <= 0xff) { PUTS(fd, "\\x"); dump_hexadecimal(fd, ch, 2); } - else if (ch < 0xffff) { + else if (ch <= 0xffff) { PUTS(fd, "\\u"); dump_hexadecimal(fd, ch, 4); } @@ -618,9 +619,9 @@ dump_frame(int fd, PyFrameObject *frame) if (code != NULL && code->co_filename != NULL && PyUnicode_Check(code->co_filename)) { - write(fd, "\"", 1); + PUTS(fd, "\""); dump_ascii(fd, code->co_filename); - write(fd, "\"", 1); + PUTS(fd, "\""); } else { PUTS(fd, "???"); } @@ -637,7 +638,7 @@ dump_frame(int fd, PyFrameObject *frame) else PUTS(fd, "???"); - write(fd, "\n", 1); + PUTS(fd, "\n"); } static void @@ -667,6 +668,12 @@ dump_traceback(int fd, PyThreadState *tstate, int write_header) } } +/* Dump the traceback of a Python thread into fd. Use write() to write the + traceback and retry if write() is interrupted by a signal (failed with + EINTR), but don't call the Python signal handler. + + The caller is responsible to call PyErr_CheckSignals() to call Python signal + handlers if signals were received. */ void _Py_DumpTraceback(int fd, PyThreadState *tstate) { @@ -685,10 +692,16 @@ write_thread_id(int fd, PyThreadState *tstate, int is_current) PUTS(fd, "Current thread 0x"); else PUTS(fd, "Thread 0x"); - dump_hexadecimal(fd, (unsigned long)tstate->thread_id, sizeof(long)*2); + dump_hexadecimal(fd, (unsigned long)tstate->thread_id, sizeof(unsigned long)*2); PUTS(fd, " (most recent call first):\n"); } +/* Dump the traceback of all Python threads into fd. Use write() to write the + traceback and retry if write() is interrupted by a signal (failed with + EINTR), but don't call the Python signal handler. + + The caller is responsible to call PyErr_CheckSignals() to call Python signal + handlers if signals were received. */ const char* _Py_DumpTracebackThreads(int fd, PyInterpreterState *interp, PyThreadState *current_thread) @@ -704,10 +717,11 @@ _Py_DumpTracebackThreads(int fd, PyInterpreterState *interp, /* Dump the traceback of each thread */ tstate = PyInterpreterState_ThreadHead(interp); nthreads = 0; + _Py_BEGIN_SUPPRESS_IPH do { if (nthreads != 0) - write(fd, "\n", 1); + PUTS(fd, "\n"); if (nthreads >= MAX_NTHREADS) { PUTS(fd, "...\n"); break; @@ -717,6 +731,7 @@ _Py_DumpTracebackThreads(int fd, PyInterpreterState *interp, tstate = PyThreadState_Next(tstate); nthreads++; } while (tstate != NULL); + _Py_END_SUPPRESS_IPH return NULL; } |