diff options
Diffstat (limited to 'Python')
51 files changed, 13939 insertions, 9175 deletions
diff --git a/Python/Python-ast.c b/Python/Python-ast.c index 44fdafc..edfcbad 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 0000000..153b628 --- /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 6dff0a2..978bad1 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); @@ -613,8 +680,7 @@ setup_context(Py_ssize_t stack_level, PyObject **filename, int *lineno, goto handle_error; } else if (!is_true) { - Py_DECREF(*filename); - *filename = PyUnicode_FromString("__main__"); + Py_SETREF(*filename, PyUnicode_FromString("__main__")); if (*filename == NULL) goto handle_error; } @@ -654,16 +720,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 74fa941..df387b2 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 d50cb80..6da33f7 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,9 +2808,9 @@ 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 + test: ... here starts the operator precedence dance */ if (NCH(n) == 1) { @@ -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 53009e3..eedd7c3 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(PyObject *module, PyObject *x) +/*[clinic end generated code: output=b1b433b9e51356f5 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(PyObject *module, PyObject *iterable) +/*[clinic end generated code: output=ca2a7127276f79b3 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(PyObject *module, PyObject *iterable) +/*[clinic end generated code: output=fa65684748caa60e 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(PyObject *module, PyObject *obj) +/*[clinic end generated code: output=6d37b3f0984c7eb9 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(PyObject *module, PyObject *number) +/*[clinic end generated code: output=b6fc4ad5e649f4f7 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(PyObject *module, PyObject *obj) +/*[clinic end generated code: output=2b095d59d934cb7e 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,40 @@ 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(PyObject *module, PyObject *value, PyObject *format_spec) +/*[clinic end generated code: output=2f40bdfa4954b077 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(PyObject *module, int i) +/*[clinic end generated code: output=c733afcd200afcb7 input=3f604ef45a70750d]*/ +{ + return PyUnicode_FromOrdinal(i); +} static const char * @@ -599,8 +637,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 +646,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(PyObject *module, PyObject *source, PyObject *filename, + const char *mode, int flags, int dont_inherit, + int optimize) +/*[clinic end generated code: output=1fa176e33452bb63 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 +705,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 +732,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 +748,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 +763,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 +788,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//y, x%y). Invariant: div*y + mod == x. +[clinic start generated code]*/ + static PyObject * -builtin_divmod(PyObject *self, PyObject *args) +builtin_divmod_impl(PyObject *module, PyObject *x, PyObject *y) +/*[clinic end generated code: output=b06d8a5f6e0c745e input=175ad9c84ff41a85]*/ { - 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(PyObject *module, PyObject *source, PyObject *globals, + PyObject *locals) +/*[clinic end generated code: output=0a0824aa70093116 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 +866,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 +885,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(PyObject *module, PyObject *source, PyObject *globals, + PyObject *locals) +/*[clinic end generated code: output=3c90efc6ab68ef5d 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 +930,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 +946,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 +970,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 +978,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 +1013,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(PyObject *module) +/*[clinic end generated code: output=e5dd1527067b94d2 input=9327576f92bb48ba]*/ { PyObject *d; @@ -971,26 +1033,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(PyObject *module, PyObject *obj, PyObject *name) +/*[clinic end generated code: output=a7aff2090a4151e5 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 +1069,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 +1266,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 +1309,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(PyObject *module, PyObject *obj, PyObject *name, + PyObject *value) +/*[clinic end generated code: output=dc2ce1d1add9acb4 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(PyObject *module, PyObject *obj, PyObject *name) +/*[clinic end generated code: output=85134bc58dff79fa 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(PyObject *module, PyObject *obj) +/*[clinic end generated code: output=237668e9d7688db7 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(PyObject *module, PyObject *number) +/*[clinic end generated code: output=e46b612169099408 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 +1429,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(PyObject *module, PyObject *obj) +/*[clinic end generated code: output=fa7a270d314dfb6c 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(PyObject *module) +/*[clinic end generated code: output=b46c94015ce11448 input=7874018d478d5c4b]*/ { PyObject *d; @@ -1364,11 +1472,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 +1574,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 +1591,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 +1608,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(PyObject *module, PyObject *number) +/*[clinic end generated code: output=40a34656b6875352 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(PyObject *module, PyObject *c) +/*[clinic end generated code: output=4fa5e87a323bae71 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 +1682,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(PyObject *module, PyObject *x, PyObject *y, PyObject *z) +/*[clinic end generated code: output=50a14d5d130d404b 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 +1801,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(PyObject *module, PyObject *prompt) +/*[clinic end generated code: output=83db5a191e7a0d60 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 +1827,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 +1884,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 +1907,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 +1919,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 +1929,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 +1979,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 +1991,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(PyObject *module, PyObject *obj) +/*[clinic end generated code: output=7ed3778c44fd0194 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 +2055,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 +2125,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 +2158,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(PyObject *module, PyObject *iterable, PyObject *start) +/*[clinic end generated code: output=df758cec7d1d302f 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 +2210,6 @@ builtin_sum(PyObject *self, PyObject *args) Py_DECREF(iter); return NULL; } - Py_INCREF(result); } @@ -2166,62 +2335,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(PyObject *module, PyObject *obj, + PyObject *class_or_tuple) +/*[clinic end generated code: output=6faf01472c13b003 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(PyObject *module, PyObject *cls, + PyObject *class_or_tuple) +/*[clinic end generated code: output=358412410cd7a250 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 +2585,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 7a0cb7f..c632488 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(); @@ -1549,7 +1563,7 @@ PyEval_EvalFrameEx(PyFrameObject *f, int throwflag) if (PyUnicode_CheckExact(left) && PyUnicode_CheckExact(right)) { sum = unicode_concatenate(left, right, f, next_instr); - /* unicode_concatenate consumed the ref to v */ + /* unicode_concatenate consumed the ref to left */ } else { sum = PyNumber_Add(left, right); @@ -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(); @@ -1736,7 +1762,7 @@ PyEval_EvalFrameEx(PyFrameObject *f, int throwflag) PyObject *sum; if (PyUnicode_CheckExact(left) && PyUnicode_CheckExact(right)) { sum = unicode_concatenate(left, right, f, next_instr); - /* unicode_concatenate consumed the ref to v */ + /* unicode_concatenate consumed the ref to left */ } else { sum = PyNumber_InPlaceAdd(left, right); @@ -1827,7 +1853,7 @@ PyEval_EvalFrameEx(PyFrameObject *f, int throwflag) PyObject *v = THIRD(); int err; STACKADJ(-3); - /* v[w] = u */ + /* container[sub] = v */ err = PyObject_SetItem(container, sub, v); Py_DECREF(v); Py_DECREF(container); @@ -1842,7 +1868,7 @@ PyEval_EvalFrameEx(PyFrameObject *f, int throwflag) PyObject *container = SECOND(); int err; STACKADJ(-2); - /* del v[w] */ + /* del container[sub] */ err = PyObject_DelItem(container, sub); Py_DECREF(container); Py_DECREF(sub); @@ -1900,11 +1926,166 @@ 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; + } + + if (Py_TYPE(iter)->tp_as_async != NULL && + Py_TYPE(iter)->tp_as_async->am_anext != NULL) { + + /* Starting with CPython 3.5.2 __aiter__ should return + asynchronous iterators directly (not awaitables that + resolve to asynchronous iterators.) + + Therefore, we check if the object that was returned + from __aiter__ has an __anext__ method. If it does, + we wrap it in an awaitable that resolves to `iter`. + + See http://bugs.python.org/issue27243 for more + details. + */ + + PyObject *wrapper = _PyAIterWrapper_New(iter); + Py_DECREF(iter); + SET_TOP(wrapper); + DISPATCH(); + } + + 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); + + if (PyErr_WarnFormat( + PyExc_PendingDeprecationWarning, 1, + "'%.100s' implements legacy __aiter__ protocol; " + "__aiter__ should return an asynchronous " + "iterator, not awaitable", + type->tp_name)) + { + /* Warning was converted to an error. */ + Py_DECREF(awaitable); + SET_TOP(NULL); + goto error; + } + } + + 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); + + if (iter != NULL && PyCoro_CheckExact(iter)) { + PyObject *yf = _PyGen_yf((PyGenObject*)iter); + if (yf != NULL) { + /* `iter` is a coroutine object that is being + awaited, `yf` is a pointer to the current awaitable + being awaited on. */ + Py_DECREF(yf); + Py_CLEAR(iter); + PyErr_SetString( + PyExc_RuntimeError, + "coroutine is being awaited already"); + /* The code below jumps to `error` if `iter` is NULL. */ + } + } + + 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); @@ -1926,7 +2107,7 @@ PyEval_EvalFrameEx(PyFrameObject *f, int throwflag) SET_TOP(val); DISPATCH(); } - /* x remains on stack, retval is value to be yielded */ + /* receiver remains on stack, retval is value to be yielded */ f->f_stacktop = stack_pointer; why = WHY_YIELD; /* and repeat... */ @@ -2233,6 +2414,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 +2540,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 +2596,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(); } @@ -2405,7 +2728,7 @@ PyEval_EvalFrameEx(PyFrameObject *f, int throwflag) STACKADJ(-2); map = stack_pointer[-oparg]; /* dict */ assert(PyDict_CheckExact(map)); - err = PyDict_SetItem(map, key, value); /* v[w] = u */ + err = PyDict_SetItem(map, key, value); /* map[key] = value */ Py_DECREF(value); Py_DECREF(key); if (err != 0) @@ -2655,6 +2978,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 +3058,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 +3117,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 +3145,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 +3194,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; @@ -2867,8 +3265,7 @@ PyEval_EvalFrameEx(PyFrameObject *f, int throwflag) Py_INCREF(self); func = PyMethod_GET_FUNCTION(func); Py_INCREF(func); - Py_DECREF(*pfunc); - *pfunc = self; + Py_SETREF(*pfunc, self); na++; /* n++; */ } else @@ -2923,6 +3320,7 @@ PyEval_EvalFrameEx(PyFrameObject *f, int throwflag) PyObject *anns = PyDict_New(); if (anns == NULL) { Py_DECREF(func); + Py_DECREF(names); goto error; } name_ix = PyTuple_Size(names); @@ -2938,9 +3336,11 @@ PyEval_EvalFrameEx(PyFrameObject *f, int throwflag) if (err != 0) { Py_DECREF(anns); Py_DECREF(func); + Py_DECREF(names); goto error; } } + Py_DECREF(names); if (PyFunction_SetAnnotations(func, anns) != 0) { /* Can't happen unless @@ -2950,7 +3350,6 @@ PyEval_EvalFrameEx(PyFrameObject *f, int throwflag) goto error; } Py_DECREF(anns); - Py_DECREF(names); } /* XXX Maybe this should be a separate opcode? */ @@ -3026,6 +3425,7 @@ PyEval_EvalFrameEx(PyFrameObject *f, int throwflag) goto dispatch_opcode; } + #if USE_COMPUTED_GOTOS _unknown_opcode: #endif @@ -3168,11 +3568,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 +3629,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 +3786,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 +3973,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 +3996,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 +4031,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 +4231,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 +4258,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 +4272,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 +4458,22 @@ PyEval_SetTrace(Py_tracefunc func, PyObject *arg) || (tstate->c_profilefunc != NULL)); } +void +_PyEval_SetCoroutineWrapper(PyObject *wrapper) +{ + PyThreadState *tstate = PyThreadState_GET(); + + Py_XINCREF(wrapper); + Py_XSETREF(tstate->coroutine_wrapper, wrapper); +} + +PyObject * +_PyEval_GetCoroutineWrapper(void) +{ + PyThreadState *tstate = PyThreadState_GET(); + return tstate->coroutine_wrapper; +} + PyObject * PyEval_GetBuiltins(void) { @@ -4086,8 +4552,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 +4580,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 +4682,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 +4710,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); @@ -4251,8 +4720,7 @@ call_function(PyObject ***pp_stack, int oparg Py_INCREF(self); func = PyMethod_GET_FUNCTION(func); Py_INCREF(func); - Py_DECREF(*pfunc); - *pfunc = self; + Py_SETREF(*pfunc, self); na++; n++; } else @@ -4264,9 +4732,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 +4746,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 +4766,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 +4810,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,20 +4978,28 @@ 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)) { PyObject *t = NULL; + if (Py_TYPE(stararg)->tp_iter == NULL && + !PySequence_Check(stararg)) { + PyErr_Format(PyExc_TypeError, + "%.200s%.200s argument after * " + "must be an iterable, not %.200s", + PyEval_GetFuncName(func), + PyEval_GetFuncDesc(func), + stararg->ob_type->tp_name); + goto ext_call_fail; + } t = PySequence_Tuple(stararg); if (t == NULL) { - if (PyErr_ExceptionMatches(PyExc_TypeError)) { - PyErr_Format(PyExc_TypeError, - "%.200s%.200s argument after * " - "must be a sequence, not %.200s", - PyEval_GetFuncName(func), - PyEval_GetFuncDesc(func), - stararg->ob_type->tp_name); - } goto ext_call_fail; } Py_DECREF(stararg); @@ -4529,11 +5007,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 +5036,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 +5129,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 2702d5c..8d38ee9 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" @@ -111,7 +111,7 @@ static _Py_atomic_int gil_locked = {-1}; static unsigned long gil_switch_number = 0; /* Last PyThreadState holding / having held the GIL. This helps us know whether anyone else was scheduled after we dropped the GIL. */ -static _Py_atomic_address gil_last_holder = {NULL}; +static _Py_atomic_address gil_last_holder = {0}; /* This condition variable allows one or several threads to wait until the GIL is released. In addition, the mutex also protects the above @@ -142,7 +142,7 @@ static void create_gil(void) #ifdef FORCE_SWITCHING COND_INIT(switch_cond); #endif - _Py_atomic_store_relaxed(&gil_last_holder, NULL); + _Py_atomic_store_relaxed(&gil_last_holder, 0); _Py_ANNOTATE_RWLOCK_CREATE(&gil_locked); _Py_atomic_store_explicit(&gil_locked, 0, _Py_memory_order_release); } @@ -178,7 +178,7 @@ static void drop_gil(PyThreadState *tstate) /* Sub-interpreter support: threads might have been switched under our feet using PyThreadState_Swap(). Fix the GIL last holder variable so that our heuristics work. */ - _Py_atomic_store_relaxed(&gil_last_holder, tstate); + _Py_atomic_store_relaxed(&gil_last_holder, (Py_uintptr_t)tstate); } MUTEX_LOCK(gil_mutex); @@ -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,8 +239,8 @@ _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)) { - _Py_atomic_store_relaxed(&gil_last_holder, tstate); + if (tstate != (PyThreadState*)_Py_atomic_load_relaxed(&gil_last_holder)) { + _Py_atomic_store_relaxed(&gil_last_holder, (Py_uintptr_t)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 0000000..4e2b1f1 --- /dev/null +++ b/Python/clinic/bltinmodule.c.h @@ -0,0 +1,662 @@ +/*[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(PyObject *module, PyObject *value, PyObject *format_spec); + +static PyObject * +builtin_format(PyObject *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(PyObject *module, int i); + +static PyObject * +builtin_chr(PyObject *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(PyObject *module, PyObject *source, PyObject *filename, + const char *mode, int flags, int dont_inherit, + int optimize); + +static PyObject * +builtin_compile(PyObject *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//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(PyObject *module, PyObject *x, PyObject *y); + +static PyObject * +builtin_divmod(PyObject *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(PyObject *module, PyObject *source, PyObject *globals, + PyObject *locals); + +static PyObject * +builtin_eval(PyObject *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(PyObject *module, PyObject *source, PyObject *globals, + PyObject *locals); + +static PyObject * +builtin_exec(PyObject *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(PyObject *module); + +static PyObject * +builtin_globals(PyObject *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(PyObject *module, PyObject *obj, PyObject *name); + +static PyObject * +builtin_hasattr(PyObject *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(PyObject *module, PyObject *obj, PyObject *name, + PyObject *value); + +static PyObject * +builtin_setattr(PyObject *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(PyObject *module, PyObject *obj, PyObject *name); + +static PyObject * +builtin_delattr(PyObject *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(PyObject *module); + +static PyObject * +builtin_locals(PyObject *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(PyObject *module, PyObject *x, PyObject *y, PyObject *z); + +static PyObject * +builtin_pow(PyObject *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(PyObject *module, PyObject *prompt); + +static PyObject * +builtin_input(PyObject *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(PyObject *module, PyObject *iterable, PyObject *start); + +static PyObject * +builtin_sum(PyObject *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(PyObject *module, PyObject *obj, + PyObject *class_or_tuple); + +static PyObject * +builtin_isinstance(PyObject *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(PyObject *module, PyObject *cls, + PyObject *class_or_tuple); + +static PyObject * +builtin_issubclass(PyObject *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=9031270b64c794b8 input=a9049054013a1b77]*/ diff --git a/Python/clinic/import.c.h b/Python/clinic/import.c.h new file mode 100644 index 0000000..05d79ac --- /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(PyObject *module); + +static PyObject * +_imp_lock_held(PyObject *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(PyObject *module); + +static PyObject * +_imp_acquire_lock(PyObject *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(PyObject *module); + +static PyObject * +_imp_release_lock(PyObject *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(PyObject *module, PyCodeObject *code, + PyObject *path); + +static PyObject * +_imp__fix_co_filename(PyObject *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(PyObject *module); + +static PyObject * +_imp_extension_suffixes(PyObject *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(PyObject *module, PyObject *name); + +static PyObject * +_imp_init_frozen(PyObject *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(PyObject *module, PyObject *name); + +static PyObject * +_imp_get_frozen_object(PyObject *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(PyObject *module, PyObject *name); + +static PyObject * +_imp_is_frozen_package(PyObject *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(PyObject *module, PyObject *name); + +static PyObject * +_imp_is_builtin(PyObject *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(PyObject *module, PyObject *name); + +static PyObject * +_imp_is_frozen(PyObject *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(PyObject *module, PyObject *spec, PyObject *file); + +static PyObject * +_imp_create_dynamic(PyObject *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(PyObject *module, PyObject *mod); + +static PyObject * +_imp_exec_dynamic(PyObject *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(PyObject *module, PyObject *mod); + +static PyObject * +_imp_exec_builtin(PyObject *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=90ad6e5833e6170d input=a9049054013a1b77]*/ diff --git a/Python/codecs.c b/Python/codecs.c index 27f2aeb..fe57d0d 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"; @@ -402,7 +403,7 @@ wrap_codec_error(const char *operation, operation, encoding); } -/* Encode an object (e.g. an Unicode object) using the given encoding +/* Encode an object (e.g. a Unicode object) using the given encoding and return the resulting encoded object (usually a Python string). errors is passed to the encoder factory as argument if non-NULL. */ @@ -449,7 +450,7 @@ _PyCodec_EncodeInternal(PyObject *object, } /* Decode an object (usually a Python string) using the given encoding - and return an equivalent object (e.g. an Unicode object). + and return an equivalent object (e.g. a Unicode object). errors is passed to the decoder factory as argument if non-NULL. */ @@ -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 ff62487..93f47e0 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 *); @@ -394,7 +393,7 @@ list2dict(PyObject *list) return NULL; } k = PyList_GET_ITEM(list, i); - k = PyTuple_Pack(2, k, k->ob_type); + k = _PyCode_ConstantKey(k); if (k == NULL || PyDict_SetItem(dict, k, v) < 0) { Py_XDECREF(k); Py_DECREF(v); @@ -457,7 +456,7 @@ dictbytype(PyObject *src, int scope_type, int flag, Py_ssize_t offset) return NULL; } i++; - tuple = PyTuple_Pack(2, k, k->ob_type); + tuple = _PyCode_ConstantKey(k); if (!tuple || PyDict_SetItem(dest, tuple, item) < 0) { Py_DECREF(sorted_keys); Py_DECREF(item); @@ -560,7 +559,7 @@ compiler_enter_scope(struct compiler *c, identifier name, compiler_unit_free(u); return 0; } - tuple = PyTuple_Pack(2, name, Py_TYPE(name)); + tuple = _PyCode_ConstantKey(name); if (!tuple) { compiler_unit_free(u); return 0; @@ -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; } @@ -1077,54 +1100,17 @@ compiler_add_o(struct compiler *c, PyObject *dict, PyObject *o) { PyObject *t, *v; Py_ssize_t arg; - double d; - - /* necessary to make sure types aren't coerced (e.g., float and complex) */ - /* _and_ to distinguish 0.0 from -0.0 e.g. on IEEE platforms */ - if (PyFloat_Check(o)) { - d = PyFloat_AS_DOUBLE(o); - /* all we need is to make the tuple different in either the 0.0 - * or -0.0 case from all others, just to avoid the "coercion". - */ - if (d == 0.0 && copysign(1.0, d) < 0.0) - t = PyTuple_Pack(3, o, o->ob_type, Py_None); - else - t = PyTuple_Pack(2, o, o->ob_type); - } - else if (PyComplex_Check(o)) { - Py_complex z; - int real_negzero, imag_negzero; - /* For the complex case we must make complex(x, 0.) - different from complex(x, -0.) and complex(0., y) - different from complex(-0., y), for any x and y. - All four complex zeros must be distinguished.*/ - z = PyComplex_AsCComplex(o); - real_negzero = z.real == 0.0 && copysign(1.0, z.real) < 0.0; - imag_negzero = z.imag == 0.0 && copysign(1.0, z.imag) < 0.0; - if (real_negzero && imag_negzero) { - t = PyTuple_Pack(5, o, o->ob_type, - Py_None, Py_None, Py_None); - } - else if (imag_negzero) { - t = PyTuple_Pack(4, o, o->ob_type, Py_None, Py_None); - } - else if (real_negzero) { - t = PyTuple_Pack(3, o, o->ob_type, Py_None); - } - else { - t = PyTuple_Pack(2, o, o->ob_type); - } - } - else { - t = PyTuple_Pack(2, o, o->ob_type); - } + + t = _PyCode_ConstantKey(o); if (t == NULL) return -1; 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) { @@ -1429,7 +1415,7 @@ static int compiler_lookup_arg(PyObject *dict, PyObject *name) { PyObject *k, *v; - k = PyTuple_Pack(2, name, name->ob_type); + k = _PyCode_ConstantKey(name); if (k == NULL) return -1; v = PyDict_GetItem(dict, k); @@ -1508,6 +1494,9 @@ static int compiler_visit_kwonlydefaults(struct compiler *c, asdl_seq *kwonlyargs, asdl_seq *kw_defaults) { + /* Return the number of defaults + 1. + Returns 0 on error. + */ int i, default_count = 0; for (i = 0; i < asdl_seq_LEN(kwonlyargs); i++) { arg_ty arg = asdl_seq_GET(kwonlyargs, i); @@ -1515,16 +1504,16 @@ compiler_visit_kwonlydefaults(struct compiler *c, asdl_seq *kwonlyargs, if (default_) { PyObject *mangled = _Py_Mangle(c->u->u_private, arg->arg); if (!mangled) - return -1; + return 0; ADDOP_O(c, LOAD_CONST, mangled, consts); Py_DECREF(mangled); if (!compiler_visit_expr(c, default_)) { - return -1; + return 0; } default_count++; } } - return default_count; + return default_count + 1; } static int @@ -1536,32 +1525,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 @@ -1569,28 +1557,28 @@ compiler_visit_annotations(struct compiler *c, arguments_ty args, expr_ty returns) { /* Push arg annotations and a list of the argument names. Return the # - of items pushed. The expressions are evaluated out-of-order wrt the + of items pushed + 1. The expressions are evaluated out-of-order wrt the source code. - More than 2^16-1 annotations is a SyntaxError. Returns -1 on error. + More than 2^16-1 annotations is a SyntaxError. Returns 0 on error. */ static identifier return_str; PyObject *names; Py_ssize_t len; names = PyList_New(0); if (!names) - return -1; + return 0; - 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 +1587,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; } @@ -1629,27 +1617,51 @@ compiler_visit_annotations(struct compiler *c, arguments_ty args, Py_DECREF(names); /* We just checked that len <= 65535, see above */ - return Py_SAFE_DOWNCAST(len, Py_ssize_t, int); + return Py_SAFE_DOWNCAST(len + 1, Py_ssize_t, int); error: Py_DECREF(names); - return -1; + return 0; } 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; + - assert(s->kind == FunctionDef_kind); + if (is_async) { + assert(s->kind == AsyncFunctionDef_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; @@ -1658,21 +1670,22 @@ compiler_function(struct compiler *c, stmt_ty s) if (args->kwonlyargs) { int res = compiler_visit_kwonlydefaults(c, args->kwonlyargs, args->kw_defaults); - if (res < 0) + if (res == 0) return 0; - kw_default_count = res; + kw_default_count = res - 1; } num_annotations = compiler_visit_annotations(c, args, returns); - if (num_annotations < 0) + if (num_annotations == 0) return 0; + num_annotations--; 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 +1696,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 +1715,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 +1726,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 @@ -1745,8 +1760,7 @@ compiler_class(struct compiler *c, stmt_ty s) { /* use the class name for name mangling */ Py_INCREF(s->v.ClassDef.name); - Py_XDECREF(c->u->u_private); - c->u->u_private = s->v.ClassDef.name; + Py_XSETREF(c->u->u_private, s->v.ClassDef.name); /* load (global) __name__ ... */ str = PyUnicode_InternFromString("__name__"); if (!str || !compiler_nameop(c, str, Load)) { @@ -1821,9 +1835,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 */ @@ -1881,8 +1893,8 @@ compiler_lambda(struct compiler *c, expr_ty e) if (args->kwonlyargs) { int res = compiler_visit_kwonlydefaults(c, args->kwonlyargs, args->kw_defaults); - if (res < 0) return 0; - kw_default_count = res; + if (res == 0) return 0; + kw_default_count = res - 1; } if (!compiler_enter_scope(c, name, COMPILER_SCOPE_LAMBDA, (void *)e, e->lineno)) @@ -1938,7 +1950,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 +1960,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 +1998,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) { @@ -2309,7 +2407,7 @@ compiler_import_as(struct compiler *c, identifier name, identifier asname) Py_ssize_t dot = PyUnicode_FindChar(name, '.', 0, PyUnicode_GET_LENGTH(name), 1); if (dot == -2) - return -1; + return 0; if (dot != -1) { /* Consume the base module name to get the first attribute */ Py_ssize_t pos = dot + 1; @@ -2318,12 +2416,12 @@ compiler_import_as(struct compiler *c, identifier name, identifier asname) dot = PyUnicode_FindChar(name, '.', pos, PyUnicode_GET_LENGTH(name), 1); if (dot == -2) - return -1; + return 0; attr = PyUnicode_Substring(name, pos, (dot != -1) ? dot : PyUnicode_GET_LENGTH(name)); if (!attr) - return -1; + return 0; ADDOP_O(c, LOAD_ATTR, attr, names); Py_DECREF(attr); pos = dot + 1; @@ -2512,7 +2610,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 +2689,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 +2729,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 +2795,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 +2858,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 +2976,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++; + } + else { + VISIT(c, expr, elt); + nseen++; + } + } + if (nsubitems) { + if (nseen) { + ADDOP_I(c, inner_op, nseen); + nsubitems++; + } + ADDOP_I(c, outer_op, nsubitems); + } + else + ADDOP_I(c, single_op, nseen); + return 1; +} + +static int +assignment_helper(struct compiler *c, asdl_seq *elts) +{ + Py_ssize_t n = asdl_seq_LEN(elts); + Py_ssize_t i; + int seen_star = 0; + for (i = 0; i < n; i++) { + expr_ty elt = asdl_seq_GET(elts, i); + if (elt->kind == Starred_kind && !seen_star) { + if ((i >= (1 << 8)) || + (n-i-1 >= (INT_MAX >> 8))) + return compiler_error(c, + "too many expressions in " + "star-unpacking assignment"); + ADDOP_I(c, UNPACK_EX, (i + ((n-i-1) << 8))); + seen_star = 1; + asdl_seq_SET(elts, i, elt->v.Starred.value); } - if (!seen_star) { - ADDOP_I(c, UNPACK_SEQUENCE, n); + else if (elt->kind == Starred_kind) { + return compiler_error(c, + "two starred expressions in assignment"); } } - VISIT_SEQ(c, expr, e->v.List.elts); - if (e->v.List.ctx == Load) { - ADDOP_I(c, BUILD_LIST, n); + 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 +3170,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 +3178,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 (starargs) { - VISIT(c, expr, starargs); + if (nseen) { + /* Pack up any trailing positional arguments. */ + ADDOP_I(c, BUILD_TUPLE, nseen); + nsubargs++; + } + if (nsubargs) { code |= 1; + if (nsubargs > 1) { + /* If we ended up with more than one stararg, we need + to concatenate them into a single sequence. */ + ADDOP_I(c, BUILD_LIST_UNPACK, nsubargs); + } + } + + /* 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 (kwargs) { - VISIT(c, expr, kwargs); + 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) + 2 * 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 +3398,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 +3573,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 +3742,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 +3754,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 +3780,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 +3794,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 +3807,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 +3915,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: @@ -3616,7 +3980,7 @@ compiler_push_fblock(struct compiler *c, enum fblocktype t, basicblock *b) { struct fblockinfo *f; if (c->u->u_nfblocks >= CO_MAXBLOCKS) { - PyErr_SetString(PyExc_SystemError, + PyErr_SetString(PyExc_SyntaxError, "too many statically nested blocks"); return 0; } @@ -4163,9 +4527,10 @@ dict_keys_inorder(PyObject *dict, Py_ssize_t offset) return NULL; while (PyDict_Next(dict, &pos, &k, &v)) { i = PyLong_AS_LONG(v); - /* The keys of the dictionary are tuples. (see compiler_add_o) - The object we want is always first, though. */ - k = PyTuple_GET_ITEM(k, 0); + /* The keys of the dictionary are tuples. (see compiler_add_o + * and _PyCode_ConstantKey). The object we want is always second, + * though. */ + k = PyTuple_GET_ITEM(k, 1); Py_INCREF(k); assert((i - offset) < size); assert((i - offset) >= 0); @@ -4181,9 +4546,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 ef818c4..bb5b1b6 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 8996a72..3da546e 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 5ac30ed..b3ff8e2 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 5836cb3b..2bec645 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 c955414..4967afc 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 85c95b4..83a8b2bb 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 5cd1efd..7f8f134 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 ffcf0ee..f2c796e 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 b0ad9aa..e151cab 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)) { @@ -152,13 +152,7 @@ PyErr_SetString(PyObject *exception, const char *string) PyObject * PyErr_Occurred(void) { - /* If there is no thread state, PyThreadState_GET calls - Py_FatalError, which calls PyErr_Occurred. To avoid the - resulting infinite loop, we inline PyThreadState_GET here and - treat no thread as no error. */ - PyThreadState *tstate = - ((PyThreadState*)_Py_atomic_load_relaxed(&_PyThreadState_Current)); - + PyThreadState *tstate = _PyThreadState_UncheckedGet(); return tstate == NULL ? NULL : tstate->curexc_type; } @@ -315,14 +309,11 @@ finally: tstate = PyThreadState_GET(); if (++tstate->recursion_depth > Py_GetRecursionLimit()) { --tstate->recursion_depth; - /* throw away the old exception... */ - Py_DECREF(*exc); - Py_DECREF(*val); - /* ... and use the recursion error instead */ - *exc = PyExc_RuntimeError; - *val = PyExc_RecursionErrorInst; - Py_INCREF(*exc); - Py_INCREF(*val); + /* throw away the old exception and use the recursion error instead */ + Py_INCREF(PyExc_RecursionError); + Py_SETREF(*exc, PyExc_RecursionError); + Py_INCREF(PyExc_RecursionErrorInst); + Py_SETREF(*val, PyExc_RecursionErrorInst); /* just keeping the old traceback */ return; } @@ -736,9 +727,9 @@ PyErr_SetImportError(PyObject *msg, PyObject *name, PyObject *path) PyTuple_SET_ITEM(args, 0, msg); if (PyDict_SetItemString(kwargs, "name", name) < 0) - return NULL; + goto done; if (PyDict_SetItemString(kwargs, "path", path) < 0) - return NULL; + goto done; error = PyObject_Call(PyExc_ImportError, args, kwargs); if (error != NULL) { @@ -746,9 +737,9 @@ PyErr_SetImportError(PyObject *msg, PyObject *name, PyObject *path) Py_DECREF(error); } +done: Py_DECREF(args); Py_DECREF(kwargs); - return NULL; } @@ -773,34 +764,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) { @@ -905,8 +900,12 @@ PyErr_WriteUnraisable(PyObject *obj) if (obj) { if (PyFile_WriteString("Exception ignored in: ", f) < 0) goto done; - if (PyFile_WriteObject(obj, f, 0) < 0) - goto done; + if (PyFile_WriteObject(obj, f, 0) < 0) { + PyErr_Clear(); + if (PyFile_WriteString("<object repr() failed>", f) < 0) { + goto done; + } + } if (PyFile_WriteString("\n", f) < 0) goto done; } @@ -951,8 +950,12 @@ PyErr_WriteUnraisable(PyObject *obj) if (v && v != Py_None) { if (PyFile_WriteString(": ", f) < 0) goto done; - if (PyFile_WriteObject(v, f, Py_PRINT_RAW) < 0) - goto done; + if (PyFile_WriteObject(v, f, Py_PRINT_RAW) < 0) { + PyErr_Clear(); + if (PyFile_WriteString("<exception str() failed>", f) < 0) { + goto done; + } + } } if (PyFile_WriteString("\n", f) < 0) goto done; @@ -1121,6 +1124,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 31689c0..23eed71 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; @@ -169,7 +176,7 @@ check_force_ascii(void) #endif error: - /* if an error occured, force the ASCII encoding */ + /* if an error occurred, force the ASCII encoding */ return 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 a 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 a 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); @@ -698,7 +856,7 @@ set_inheritable(int fd, int inheritable, int raise, int *atomic_flag_works) return 0; } - if (errno != ENOTTY) { + if (errno != ENOTTY && errno != EACCES) { if (raise) PyErr_SetFromErrno(PyExc_OSError); return -1; @@ -707,7 +865,12 @@ set_inheritable(int fd, int inheritable, int raise, int *atomic_flag_works) /* Issue #22258: Here, ENOTTY means "Inappropriate ioctl for device". The ioctl is declared but not supported by the kernel. Remember that ioctl() doesn't work. It is the case on - Illumos-based OS for example. */ + Illumos-based OS for example. + + Issue #27057: When SELinux policy disallows ioctl it will fail + with EACCES. While FIOCLEX is safe operation it may be + unavailable because ioctl was denied altogether. + This can be the case on Android. */ ioctl_works = 0; } /* fallback to fcntl() if ioctl() does not work */ @@ -767,40 +930,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 +1029,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 +1046,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 +1065,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. 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. - Return the new file object on success, or NULL if the file cannot be open or - (if PyErr_Occurred()) on unicode error. */ + 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 +1102,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 +1359,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 +1373,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 +1404,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 +1414,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 +1447,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 +1479,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 +1491,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 +1503,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 +1522,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 +1532,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 e3a8149..8e9c502 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 */ @@ -1035,7 +1042,7 @@ format_float_internal(PyObject *value, else if (type == 'r') type = 'g'; - /* Cast "type", because if we're in unicode we need to pass a + /* Cast "type", because if we're in unicode we need to pass an 8-bit char. This is safe, because we've restricted what "type" can be. */ buf = PyOS_double_to_string(val, (char)type, precision, flags, @@ -1214,7 +1221,7 @@ format_complex_internal(PyObject *value, else if (type == 'r') type = 'g'; - /* Cast "type", because if we're in unicode we need to pass a + /* Cast "type", because if we're in unicode we need to pass an 8-bit char. This is safe, because we've restricted what "type" can be. */ re_buf = PyOS_double_to_string(re, (char)type, precision, flags, diff --git a/Python/frozen.c b/Python/frozen.c index 9bc662b..676f395 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 b05c94a..de8bd35 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 81eab54..163f87f 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 6902d13..8aab067 100644 --- a/Python/getargs.c +++ b/Python/getargs.c @@ -342,7 +342,7 @@ vgetargs1(PyObject *args, const char *format, va_list *p_va, int flags) flags, levels, msgbuf, sizeof(msgbuf), &freelist); if (msg) { - seterror(i+1, msg, levels, fname, msg); + seterror(i+1, msg, levels, fname, message); return cleanreturn(0, &freelist); } } @@ -535,9 +535,15 @@ converterr(const char *expected, PyObject *arg, char *msgbuf, size_t bufsize) { assert(expected != NULL); assert(arg != NULL); - PyOS_snprintf(msgbuf, bufsize, - "must be %.50s, not %.50s", expected, - arg == Py_None ? "None" : arg->ob_type->tp_name); + if (expected[0] == '(') { + PyOS_snprintf(msgbuf, bufsize, + "%.100s", expected); + } + else { + PyOS_snprintf(msgbuf, bufsize, + "must be %.50s, not %.50s", expected, + arg == Py_None ? "None" : arg->ob_type->tp_name); + } return msgbuf; } @@ -741,7 +747,7 @@ convertsimple(PyObject *arg, const char **p_format, va_list *p_va, int flags, if (PyLong_Check(arg)) ival = PyLong_AsUnsignedLongMask(arg); else - return converterr("integer<k>", arg, msgbuf, bufsize); + return converterr("int", arg, msgbuf, bufsize); *p = ival; break; } @@ -766,7 +772,7 @@ convertsimple(PyObject *arg, const char **p_format, va_list *p_va, int flags, if (PyLong_Check(arg)) ival = PyLong_AsUnsignedLongLongMask(arg); else - return converterr("integer<K>", arg, msgbuf, bufsize); + return converterr("int", arg, msgbuf, bufsize); *p = ival; break; } @@ -872,10 +878,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 +954,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 +1000,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); @@ -1124,9 +1129,11 @@ convertsimple(PyObject *arg, const char **p_format, va_list *p_va, int flags, } else { if (size + 1 > BUFFER_LEN) { Py_DECREF(s); - return converterr( - "(buffer overflow)", - arg, msgbuf, bufsize); + PyErr_Format(PyExc_TypeError, + "encoded string too long " + "(%zd, maximum length %zd)", + (Py_ssize_t)size, (Py_ssize_t)(BUFFER_LEN-1)); + RETURN_ERR_OCCURRED; } } memcpy(*buffer, ptr, size+1); @@ -1148,7 +1155,7 @@ convertsimple(PyObject *arg, const char **p_format, va_list *p_va, int flags, if ((Py_ssize_t)strlen(ptr) != size) { Py_DECREF(s); return converterr( - "encoded string without NULL bytes", + "encoded string without null bytes", arg, msgbuf, bufsize); } *buffer = PyMem_NEW(char, size + 1); @@ -1238,7 +1245,7 @@ convertsimple(PyObject *arg, const char **p_format, va_list *p_va, int flags, if (*format != '*') return converterr( - "invalid use of 'w' format character", + "(invalid use of 'w' format character)", arg, msgbuf, bufsize); format++; @@ -1246,7 +1253,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); @@ -1261,7 +1269,7 @@ convertsimple(PyObject *arg, const char **p_format, va_list *p_va, int flags, } default: - return converterr("impossible<bad format char>", arg, msgbuf, bufsize); + return converterr("(impossible<bad format char>)", arg, msgbuf, bufsize); } @@ -1284,7 +1292,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 +1308,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 e04999b..8212b2a 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 4f0765a..5025e75 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]*/ +_imp_lock_held_impl(PyObject *module) +/*[clinic end generated code: output=8b89384b5e1963fc 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]*/ +_imp_acquire_lock_impl(PyObject *module) +/*[clinic end generated code: output=1aff58cb0ee1b026 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]*/ +_imp_release_lock_impl(PyObject *module) +/*[clinic end generated code: output=7faab6d0be178b0a 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); @@ -725,9 +671,13 @@ PyImport_AddModuleObject(PyObject *name) PyObject *modules = PyImport_GetModuleDict(); PyObject *m; - if ((m = PyDict_GetItem(modules, name)) != NULL && - PyModule_Check(m)) + if ((m = PyDict_GetItemWithError(modules, name)) != NULL && + PyModule_Check(m)) { return m; + } + if (PyErr_Occurred()) { + return NULL; + } m = PyModule_NewObject(name); if (m == NULL) return NULL; @@ -796,7 +746,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 +774,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 +847,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 +859,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 +925,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(PyObject *module, PyCodeObject *code, + PyObject *path) +/*[clinic end generated code: output=1d002f100235587d input=895ba50e78b82f05]*/ { update_compiled_module(code, path); @@ -1104,50 +1030,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(PyObject *module, PyObject *spec) +/*[clinic end generated code: output=ace7ff22271e6f39 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 +1287,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 +1317,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; @@ -1484,6 +1438,7 @@ PyImport_ImportModuleLevelObject(PyObject *name, PyObject *given_globals, } else if (!PyUnicode_Check(package)) { PyErr_SetString(PyExc_TypeError, "__name__ must be a string"); + goto error; } Py_INCREF(package); @@ -1571,15 +1526,13 @@ PyImport_ImportModuleLevelObject(PyObject *name, PyObject *given_globals, _PyImport_AcquireLock(); #endif /* From this point forward, goto error_with_unlock! */ - if (PyDict_Check(globals)) { - builtins_import = _PyDict_GetItemId(globals, &PyId___import__); - } + /* XXX interp->builtins_copy is NULL in subinterpreter! */ + builtins_import = _PyDict_GetItemId(interp->builtins_copy ? + interp->builtins_copy : + interp->builtins, &PyId___import__); if (builtins_import == NULL) { - builtins_import = _PyDict_GetItemId(interp->builtins, &PyId___import__); - if (builtins_import == NULL) { - PyErr_SetString(PyExc_ImportError, "__import__ not found"); - goto error_with_unlock; - } + PyErr_SetString(PyExc_ImportError, "__import__ not found"); + goto error_with_unlock; } Py_INCREF(builtins_import); @@ -1868,27 +1821,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]*/ +_imp_extension_suffixes_impl(PyObject *module) +/*[clinic end generated code: output=0bf346e25a8f0cd3 input=ecdeeecfcb6f839e]*/ { PyObject *list; const char *suffix; @@ -1917,62 +1852,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 +1860,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]*/ +_imp_init_frozen_impl(PyObject *module, PyObject *name) +/*[clinic end generated code: output=fc0511ed869fd69c input=13019adfc04f3fb3]*/ { int ret; PyObject *m; @@ -2037,37 +1888,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]*/ +_imp_get_frozen_object_impl(PyObject *module, PyObject *name) +/*[clinic end generated code: output=2568cc5b7aa0da63 input=ed689bc05358fdbd]*/ { return get_frozen_object(name); } @@ -2081,37 +1904,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]*/ +_imp_is_frozen_package_impl(PyObject *module, PyObject *name) +/*[clinic end generated code: output=e70cbdb45784a1c9 input=81b6cdecd080fbb8]*/ { return is_frozen_package(name); } @@ -2125,37 +1920,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]*/ +_imp_is_builtin_impl(PyObject *module, PyObject *name) +/*[clinic end generated code: output=3bfd1162e2d3be82 input=86befdac021dd1c7]*/ { return PyLong_FromLong(is_builtin(name)); } @@ -2169,37 +1936,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]*/ +_imp_is_frozen_impl(PyObject *module, PyObject *name) +/*[clinic end generated code: output=01f408f5ec0f2577 input=7301dbca1897d66b]*/ { const struct _frozen *p; @@ -2207,84 +1946,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(PyObject *module, PyObject *spec, PyObject *file) +/*[clinic end generated code: output=83249b827a4fde77 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(PyObject *module, PyObject *mod) +/*[clinic end generated code: output=f5720ac7b465877d 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(PyObject *module, PyObject *mod) +/*[clinic end generated code: output=0262447b240c038e 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 +2083,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 +2172,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 +2181,3 @@ PyImport_AppendInittab(const char *name, PyObject* (*initfunc)(void)) #ifdef __cplusplus } #endif - diff --git a/Python/importdl.c b/Python/importdl.c index b60f1c7..1aa585d 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 6a51a91..9847652 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 75bfca4..7f6b753 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,502 @@ 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, - 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,115,185,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,2,0,100,2,0,107,4, + 0,114,150,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,110, + 42,0,124,1,0,116,6,0,106,7,0,107,7,0,114,150, + 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,181,0,124,2,0,100,2,0,107,2,0,114,181,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,12,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,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,74,0,124,0,0, + 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,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, - 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, + 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,215,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,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,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, + 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,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 0000000..27d7c8a --- /dev/null +++ b/Python/importlib_external.h @@ -0,0 +1,2606 @@ +/* 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,244,2,0,0,100,0,0,90,0,0, + 100,96,0,90,1,0,100,97,0,90,2,0,101,2,0,101, + 1,0,23,90,3,0,100,4,0,100,5,0,132,0,0,90, + 4,0,100,6,0,100,7,0,132,0,0,90,5,0,100,8, + 0,100,9,0,132,0,0,90,6,0,100,10,0,100,11,0, + 132,0,0,90,7,0,100,12,0,100,13,0,132,0,0,90, + 8,0,100,14,0,100,15,0,132,0,0,90,9,0,100,16, + 0,100,17,0,132,0,0,90,10,0,100,18,0,100,19,0, + 132,0,0,90,11,0,100,20,0,100,21,0,132,0,0,90, + 12,0,100,22,0,100,23,0,100,24,0,132,1,0,90,13, + 0,101,14,0,101,13,0,106,15,0,131,1,0,90,16,0, + 100,25,0,106,17,0,100,26,0,100,27,0,131,2,0,100, + 28,0,23,90,18,0,101,19,0,106,20,0,101,18,0,100, + 27,0,131,2,0,90,21,0,100,29,0,90,22,0,100,30, + 0,90,23,0,100,31,0,103,1,0,90,24,0,100,32,0, + 103,1,0,90,25,0,101,25,0,4,90,26,0,90,27,0, + 100,33,0,100,34,0,100,33,0,100,35,0,100,36,0,132, + 1,1,90,28,0,100,37,0,100,38,0,132,0,0,90,29, + 0,100,39,0,100,40,0,132,0,0,90,30,0,100,41,0, + 100,42,0,132,0,0,90,31,0,100,43,0,100,44,0,132, + 0,0,90,32,0,100,45,0,100,46,0,100,47,0,100,48, + 0,132,0,1,90,33,0,100,49,0,100,50,0,132,0,0, + 90,34,0,100,51,0,100,52,0,132,0,0,90,35,0,100, + 33,0,100,33,0,100,33,0,100,53,0,100,54,0,132,3, + 0,90,36,0,100,33,0,100,33,0,100,33,0,100,55,0, + 100,56,0,132,3,0,90,37,0,100,57,0,100,57,0,100, + 58,0,100,59,0,132,2,0,90,38,0,100,60,0,100,61, + 0,132,0,0,90,39,0,101,40,0,131,0,0,90,41,0, + 100,33,0,100,62,0,100,33,0,100,63,0,101,41,0,100, + 64,0,100,65,0,132,1,2,90,42,0,71,100,66,0,100, + 67,0,132,0,0,100,67,0,131,2,0,90,43,0,71,100, + 68,0,100,69,0,132,0,0,100,69,0,131,2,0,90,44, + 0,71,100,70,0,100,71,0,132,0,0,100,71,0,101,44, + 0,131,3,0,90,45,0,71,100,72,0,100,73,0,132,0, + 0,100,73,0,131,2,0,90,46,0,71,100,74,0,100,75, + 0,132,0,0,100,75,0,101,46,0,101,45,0,131,4,0, + 90,47,0,71,100,76,0,100,77,0,132,0,0,100,77,0, + 101,46,0,101,44,0,131,4,0,90,48,0,103,0,0,90, + 49,0,71,100,78,0,100,79,0,132,0,0,100,79,0,101, + 46,0,101,44,0,131,4,0,90,50,0,71,100,80,0,100, + 81,0,132,0,0,100,81,0,131,2,0,90,51,0,71,100, + 82,0,100,83,0,132,0,0,100,83,0,131,2,0,90,52, + 0,71,100,84,0,100,85,0,132,0,0,100,85,0,131,2, + 0,90,53,0,71,100,86,0,100,87,0,132,0,0,100,87, + 0,131,2,0,90,54,0,100,33,0,100,88,0,100,89,0, + 132,1,0,90,55,0,100,90,0,100,91,0,132,0,0,90, + 56,0,100,92,0,100,93,0,132,0,0,90,57,0,100,94, + 0,100,95,0,132,0,0,90,58,0,100,33,0,83,41,98, + 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,3,0,0,0,3,0,0,0,115,88,0, + 0,0,116,0,0,106,1,0,106,2,0,116,3,0,131,1, + 0,114,72,0,116,0,0,106,1,0,106,2,0,116,4,0, + 131,1,0,114,45,0,100,1,0,137,0,0,110,6,0,100, + 2,0,137,0,0,135,0,0,102,1,0,100,3,0,100,4, + 0,134,0,0,125,0,0,110,12,0,100,5,0,100,4,0, + 132,0,0,125,0,0,124,0,0,83,41,6,78,90,12,80, + 89,84,72,79,78,67,65,83,69,79,75,115,12,0,0,0, + 80,89,84,72,79,78,67,65,83,69,79,75,99,0,0,0, + 0,0,0,0,0,0,0,0,0,2,0,0,0,19,0,0, + 0,115,13,0,0,0,136,0,0,116,0,0,106,1,0,107, + 6,0,83,41,1,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,41,2,218,3, + 95,111,115,90,7,101,110,118,105,114,111,110,169,0,41,1, + 218,3,107,101,121,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,37, + 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,6,0, + 0,0,114,7,0,0,0,41,0,0,0,115,2,0,0,0, + 0,2,41,5,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,218,35,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,95,83,84,82,95,75,69, + 89,41,1,114,7,0,0,0,114,4,0,0,0,41,1,114, + 5,0,0,0,114,6,0,0,0,218,16,95,109,97,107,101, + 95,114,101,108,97,120,95,99,97,115,101,30,0,0,0,115, + 14,0,0,0,0,1,18,1,18,1,9,2,6,2,21,4, + 12,3,114,13,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,6,0,0,0,218,7,95,119,95,108,111,110,103,47, + 0,0,0,115,2,0,0,0,0,2,114,19,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,15,0,0, + 0,41,2,114,16,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,6,0,0,0, + 218,7,95,114,95,108,111,110,103,52,0,0,0,115,2,0, + 0,0,0,2,114,21,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,6,0,0,0,250,10,60,108,105,115, + 116,99,111,109,112,62,59,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,6,0,0,0, + 218,10,95,112,97,116,104,95,106,111,105,110,57,0,0,0, + 115,4,0,0,0,0,2,15,1,114,30,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,23,0,0,0,218, + 10,114,112,97,114,116,105,116,105,111,110,114,27,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,18,0,0,0,114, + 4,0,0,0,114,4,0,0,0,114,6,0,0,0,218,11, + 95,112,97,116,104,95,115,112,108,105,116,63,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,40,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,37,0,0,0,114,4,0,0,0,114,4,0,0,0, + 114,6,0,0,0,218,10,95,112,97,116,104,95,115,116,97, + 116,75,0,0,0,115,2,0,0,0,0,7,114,41,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,41,0,0,0,218,7,79,83,69,114,114,111,114, + 218,7,115,116,95,109,111,100,101,41,3,114,37,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,6,0,0,0, + 218,18,95,112,97,116,104,95,105,115,95,109,111,100,101,95, + 116,121,112,101,85,0,0,0,115,10,0,0,0,0,2,3, + 1,16,1,13,1,9,1,114,45,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,45,0, + 0,0,41,1,114,37,0,0,0,114,4,0,0,0,114,4, + 0,0,0,114,6,0,0,0,218,12,95,112,97,116,104,95, + 105,115,102,105,108,101,94,0,0,0,115,2,0,0,0,0, + 2,114,46,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,45,0,0,0,41,1,114,37,0,0, + 0,114,4,0,0,0,114,4,0,0,0,114,6,0,0,0, + 218,11,95,112,97,116,104,95,105,115,100,105,114,99,0,0, + 0,115,6,0,0,0,0,2,6,1,12,1,114,48,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,42,0,0,0,90,6, + 117,110,108,105,110,107,41,6,114,37,0,0,0,218,4,100, + 97,116,97,114,44,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,6,0,0,0,218,13,95,119,114, + 105,116,101,95,97,116,111,109,105,99,106,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,57,0, + 0,0,105,23,13,0,0,233,2,0,0,0,114,15,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,32,0,0,0,114,31,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,40,0,0,0,114,34,0,0,0,114, + 8,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,28,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,49,0,0,0,218,4,95,79,80,84,114, + 30,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,37,0,0,0,90,14,100,101,98,117,103,95, + 111,118,101,114,114,105,100,101,114,59,0,0,0,218,7,109, + 101,115,115,97,103,101,218,4,104,101,97,100,114,39,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,6,0,0,0,218,17,99,97,99,104,101,95,102, + 114,111,109,95,115,111,117,114,99,101,254,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,81,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,60,0,0,0,114,58,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,61,0,0,0,62,2,0,0,0,114,58, + 0,0,0,114,82,0,0,0,233,254,255,255,255,41,17,114, + 8,0,0,0,114,66,0,0,0,114,67,0,0,0,114,68, + 0,0,0,114,40,0,0,0,114,75,0,0,0,114,73,0, + 0,0,114,49,0,0,0,218,5,99,111,117,110,116,114,36, + 0,0,0,114,10,0,0,0,114,74,0,0,0,114,33,0, + 0,0,114,72,0,0,0,218,9,112,97,114,116,105,116,105, + 111,110,114,30,0,0,0,218,15,83,79,85,82,67,69,95, + 83,85,70,70,73,88,69,83,41,8,114,37,0,0,0,114, + 78,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,59,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,6,0,0,0,218,17,115,111,117,114,99,101, + 95,102,114,111,109,95,99,97,99,104,101,42,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,87,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,61,0,0,0,78,114,60,0,0,0,114,82, + 0,0,0,114,31,0,0,0,90,2,112,121,233,253,255,255, + 255,233,255,255,255,255,114,89,0,0,0,41,7,114,33,0, + 0,0,114,34,0,0,0,218,5,108,111,119,101,114,114,87, + 0,0,0,114,68,0,0,0,114,73,0,0,0,114,46,0, + 0,0,41,5,218,13,98,121,116,101,99,111,100,101,95,112, + 97,116,104,114,80,0,0,0,114,38,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, + 6,0,0,0,218,15,95,103,101,116,95,115,111,117,114,99, + 101,102,105,108,101,75,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,93,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,86,0,0,0,114,81,0,0,0,114,68,0, + 0,0,114,76,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,6,0, + 0,0,218,11,95,103,101,116,95,99,97,99,104,101,100,94, + 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,97,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,41,0,0,0,114,43,0,0,0, + 114,42,0,0,0,41,2,114,37,0,0,0,114,44,0,0, + 0,114,4,0,0,0,114,4,0,0,0,114,6,0,0,0, + 218,10,95,99,97,108,99,95,109,111,100,101,106,1,0,0, + 115,12,0,0,0,0,2,3,1,19,1,13,1,11,3,10, + 1,114,99,0,0,0,218,9,118,101,114,98,111,115,105,116, + 121,114,31,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,56,0,0, + 0,78,41,2,114,101,0,0,0,114,102,0,0,0,41,7, + 114,8,0,0,0,114,69,0,0,0,218,7,118,101,114,98, + 111,115,101,114,10,0,0,0,218,5,112,114,105,110,116,114, + 49,0,0,0,218,6,115,116,100,101,114,114,41,3,114,77, + 0,0,0,114,100,0,0,0,218,4,97,114,103,115,114,4, + 0,0,0,114,4,0,0,0,114,6,0,0,0,218,16,95, + 118,101,114,98,111,115,101,95,109,101,115,115,97,103,101,118, + 1,0,0,115,8,0,0,0,0,2,18,1,15,1,10,1, + 114,107,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,108,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,108,0,0, + 0,114,106,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,6,0, + 0,0,218,19,95,99,104,101,99,107,95,110,97,109,101,95, + 119,114,97,112,112,101,114,134,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,54,0,0,0,114,4,0,0, + 0,114,4,0,0,0,114,6,0,0,0,218,5,95,119,114, + 97,112,145,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,122,0, + 0,0,218,9,78,97,109,101,69,114,114,111,114,41,3,114, + 111,0,0,0,114,112,0,0,0,114,122,0,0,0,114,4, + 0,0,0,41,1,114,111,0,0,0,114,6,0,0,0,218, + 11,95,99,104,101,99,107,95,110,97,109,101,126,1,0,0, + 115,14,0,0,0,0,8,21,7,3,1,13,1,13,2,17, + 5,13,1,114,125,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,61,0,0,0,41,6,218,11,102,105,110, + 100,95,108,111,97,100,101,114,114,33,0,0,0,114,62,0, + 0,0,114,63,0,0,0,114,49,0,0,0,218,13,73,109, + 112,111,114,116,87,97,114,110,105,110,103,41,5,114,110,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,6,0, + 0,0,218,17,95,102,105,110,100,95,109,111,100,117,108,101, + 95,115,104,105,109,154,1,0,0,115,10,0,0,0,0,10, + 21,1,24,1,6,1,29,1,114,132,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,108,0,0,0,122,10, + 60,98,121,116,101,99,111,100,101,62,114,37,0,0,0,114, + 14,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,49,0,0,0,114,107,0,0,0,114, + 109,0,0,0,114,33,0,0,0,218,8,69,79,70,69,114, + 114,111,114,114,16,0,0,0,218,8,75,101,121,69,114,114, + 111,114,114,21,0,0,0,41,11,114,55,0,0,0,218,12, + 115,111,117,114,99,101,95,115,116,97,116,115,114,108,0,0, + 0,114,37,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,77,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,6,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,171,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,143,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,108,0,0,0,114,37,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,107,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,109,0,0,0,114,49,0,0,0,41,5,114, + 55,0,0,0,114,108,0,0,0,114,91,0,0,0,114,92, + 0,0,0,218,4,99,111,100,101,114,4,0,0,0,114,4, + 0,0,0,114,6,0,0,0,218,17,95,99,111,109,112,105, + 108,101,95,98,121,116,101,99,111,100,101,226,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,149,0,0,0,114,61,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,137,0,0,0,218,6,101,120,116,101, + 110,100,114,19,0,0,0,114,144,0,0,0,90,5,100,117, + 109,112,115,41,4,114,148,0,0,0,114,135,0,0,0,114, + 142,0,0,0,114,55,0,0,0,114,4,0,0,0,114,4, + 0,0,0,114,6,0,0,0,218,17,95,99,111,100,101,95, + 116,111,95,98,121,116,101,99,111,100,101,238,1,0,0,115, + 10,0,0,0,0,3,12,1,19,1,19,1,22,1,114,152, + 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,61,0,0,0,78,84,41,7,218,8,116,111, + 107,101,110,105,122,101,114,51,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,153,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,6,0,0,0,218,13,100,101,99,111,100,101, + 95,115,111,117,114,99,101,248,1,0,0,115,10,0,0,0, + 0,5,12,1,18,1,15,1,18,1,114,157,0,0,0,114, + 129,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,61,0,0,0,41,15,114,117,0, + 0,0,114,159,0,0,0,114,109,0,0,0,114,123,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,94,0,0,0,114,95, + 0,0,0,114,129,0,0,0,218,9,95,80,79,80,85,76, + 65,84,69,114,161,0,0,0,114,158,0,0,0,114,40,0, + 0,0,218,6,97,112,112,101,110,100,41,9,114,108,0,0, + 0,90,8,108,111,99,97,116,105,111,110,114,129,0,0,0, + 114,158,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,161,0,0,0,90,7,100,105,114,110,97,109, + 101,114,4,0,0,0,114,4,0,0,0,114,6,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,9,2,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,169, + 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,42,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,114,5,0,0,0,114,4,0,0, + 0,114,4,0,0,0,114,6,0,0,0,218,14,95,111,112, + 101,110,95,114,101,103,105,115,116,114,121,87,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,128, + 0,0,0,90,11,115,121,115,95,118,101,114,115,105,111,110, + 114,82,0,0,0,114,32,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,49,0,0,0, + 114,8,0,0,0,218,7,118,101,114,115,105,111,110,114,173, + 0,0,0,114,171,0,0,0,90,10,81,117,101,114,121,86, + 97,108,117,101,114,42,0,0,0,41,6,114,172,0,0,0, + 114,128,0,0,0,90,12,114,101,103,105,115,116,114,121,95, + 107,101,121,114,5,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,6,0,0,0,218,16,95,115,101,97,114,99,104, + 95,114,101,103,105,115,116,114,121,94,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,160,0,0, + 0,41,8,114,179,0,0,0,114,41,0,0,0,114,42,0, + 0,0,114,163,0,0,0,114,94,0,0,0,114,95,0,0, + 0,114,123,0,0,0,218,16,115,112,101,99,95,102,114,111, + 109,95,108,111,97,100,101,114,41,8,114,172,0,0,0,114, + 128,0,0,0,114,37,0,0,0,218,6,116,97,114,103,101, + 116,114,178,0,0,0,114,129,0,0,0,114,168,0,0,0, + 114,166,0,0,0,114,4,0,0,0,114,4,0,0,0,114, + 6,0,0,0,218,9,102,105,110,100,95,115,112,101,99,109, + 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,182,0, + 0,0,114,129,0,0,0,41,4,114,172,0,0,0,114,128, + 0,0,0,114,37,0,0,0,114,166,0,0,0,114,4,0, + 0,0,114,4,0,0,0,114,6,0,0,0,218,11,102,105, + 110,100,95,109,111,100,117,108,101,125,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, + 114,0,0,0,114,113,0,0,0,114,115,0,0,0,114,116, + 0,0,0,114,176,0,0,0,114,175,0,0,0,114,174,0, + 0,0,218,11,99,108,97,115,115,109,101,116,104,111,100,114, + 173,0,0,0,114,179,0,0,0,114,182,0,0,0,114,183, + 0,0,0,114,4,0,0,0,114,4,0,0,0,114,4,0, + 0,0,114,6,0,0,0,114,170,0,0,0,75,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,170,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,31,0,0,0,114,60,0,0, + 0,114,61,0,0,0,114,58,0,0,0,218,8,95,95,105, + 110,105,116,95,95,41,4,114,40,0,0,0,114,159,0,0, + 0,114,36,0,0,0,114,34,0,0,0,41,5,114,110,0, + 0,0,114,128,0,0,0,114,96,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,6,0,0,0,114,161,0,0,0,144,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,110,0,0,0,114,166, + 0,0,0,114,4,0,0,0,114,4,0,0,0,114,6,0, + 0,0,218,13,99,114,101,97,116,101,95,109,111,100,117,108, + 101,152,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,114,0,0,0, + 114,109,0,0,0,114,49,0,0,0,114,123,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,120,0,0,0,41,3,114,110,0,0,0,218,6,109,111, + 100,117,108,101,114,148,0,0,0,114,4,0,0,0,114,4, + 0,0,0,114,6,0,0,0,218,11,101,120,101,99,95,109, + 111,100,117,108,101,155,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,123,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,110,0,0, + 0,114,128,0,0,0,114,4,0,0,0,114,4,0,0,0, + 114,6,0,0,0,218,11,108,111,97,100,95,109,111,100,117, + 108,101,163,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,114,0,0,0, + 114,113,0,0,0,114,115,0,0,0,114,116,0,0,0,114, + 161,0,0,0,114,187,0,0,0,114,192,0,0,0,114,194, + 0,0,0,114,4,0,0,0,114,4,0,0,0,114,4,0, + 0,0,114,6,0,0,0,114,185,0,0,0,139,2,0,0, + 115,10,0,0,0,12,3,6,2,12,8,12,3,12,8,114, + 185,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,110,0,0,0,114,37,0,0,0,114,4,0,0,0,114, + 4,0,0,0,114,6,0,0,0,218,10,112,97,116,104,95, + 109,116,105,109,101,169,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,135,0,0,0,41,1,114,197, + 0,0,0,41,2,114,110,0,0,0,114,37,0,0,0,114, + 4,0,0,0,114,4,0,0,0,114,6,0,0,0,218,10, + 112,97,116,104,95,115,116,97,116,115,177,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,110, + 0,0,0,114,92,0,0,0,90,10,99,97,99,104,101,95, + 112,97,116,104,114,55,0,0,0,114,4,0,0,0,114,4, + 0,0,0,114,6,0,0,0,218,15,95,99,97,99,104,101, + 95,98,121,116,101,99,111,100,101,190,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,110,0,0,0,114,37,0,0,0,114,55,0,0, + 0,114,4,0,0,0,114,4,0,0,0,114,6,0,0,0, + 114,199,0,0,0,200,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,108,0,0,0,78,41, + 5,114,159,0,0,0,218,8,103,101,116,95,100,97,116,97, + 114,42,0,0,0,114,109,0,0,0,114,157,0,0,0,41, + 5,114,110,0,0,0,114,128,0,0,0,114,37,0,0,0, + 114,155,0,0,0,218,3,101,120,99,114,4,0,0,0,114, + 4,0,0,0,114,6,0,0,0,218,10,103,101,116,95,115, + 111,117,114,99,101,207,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,31,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,190,0,0,0,218,12,100,111, + 110,116,95,105,110,104,101,114,105,116,84,114,70,0,0,0, + 41,3,114,123,0,0,0,114,189,0,0,0,218,7,99,111, + 109,112,105,108,101,41,4,114,110,0,0,0,114,55,0,0, + 0,114,37,0,0,0,114,204,0,0,0,114,4,0,0,0, + 114,4,0,0,0,114,6,0,0,0,218,14,115,111,117,114, + 99,101,95,116,111,95,99,111,100,101,217,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, + 135,0,0,0,114,140,0,0,0,114,108,0,0,0,114,37, + 0,0,0,122,13,123,125,32,109,97,116,99,104,101,115,32, + 123,125,114,91,0,0,0,114,92,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, + 159,0,0,0,114,81,0,0,0,114,68,0,0,0,114,198, + 0,0,0,114,196,0,0,0,114,16,0,0,0,114,201,0, + 0,0,114,42,0,0,0,114,143,0,0,0,114,109,0,0, + 0,114,138,0,0,0,114,107,0,0,0,114,149,0,0,0, + 114,207,0,0,0,114,8,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, + 152,0,0,0,114,33,0,0,0,114,200,0,0,0,41,10, + 114,110,0,0,0,114,128,0,0,0,114,92,0,0,0,114, + 141,0,0,0,114,91,0,0,0,218,2,115,116,114,55,0, + 0,0,218,10,98,121,116,101,115,95,100,97,116,97,114,155, + 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,6,0,0,0,114, + 188,0,0,0,225,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,89,0,0,0,41,10,114,114,0,0,0,114, + 113,0,0,0,114,115,0,0,0,114,197,0,0,0,114,198, + 0,0,0,114,200,0,0,0,114,199,0,0,0,114,203,0, + 0,0,114,207,0,0,0,114,188,0,0,0,114,4,0,0, + 0,114,4,0,0,0,114,4,0,0,0,114,6,0,0,0, + 114,195,0,0,0,167,2,0,0,115,14,0,0,0,12,2, + 12,8,12,13,12,10,12,7,12,10,18,8,114,195,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,108,0,0,0,114,37,0,0,0,41,3, + 114,110,0,0,0,114,128,0,0,0,114,37,0,0,0,114, + 4,0,0,0,114,4,0,0,0,114,6,0,0,0,114,186, + 0,0,0,26,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,120,0,0,0,41,2,114,110,0,0,0,218,5,111, + 116,104,101,114,114,4,0,0,0,114,4,0,0,0,114,6, + 0,0,0,218,6,95,95,101,113,95,95,32,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,108,0,0,0,114, + 37,0,0,0,41,1,114,110,0,0,0,114,4,0,0,0, + 114,4,0,0,0,114,6,0,0,0,218,8,95,95,104,97, + 115,104,95,95,36,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,211,0,0,0,114,194,0,0,0,41, + 2,114,110,0,0,0,114,128,0,0,0,41,1,114,212,0, + 0,0,114,4,0,0,0,114,6,0,0,0,114,194,0,0, + 0,39,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,37,0,0,0,41,2,114,110,0,0, + 0,114,128,0,0,0,114,4,0,0,0,114,4,0,0,0, + 114,6,0,0,0,114,159,0,0,0,51,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,51,0,0,0,114,52,0,0,0,90,4,114, + 101,97,100,41,3,114,110,0,0,0,114,37,0,0,0,114, + 56,0,0,0,114,4,0,0,0,114,4,0,0,0,114,6, + 0,0,0,114,201,0,0,0,56,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,114,0,0, + 0,114,113,0,0,0,114,115,0,0,0,114,116,0,0,0, + 114,186,0,0,0,114,214,0,0,0,114,216,0,0,0,114, + 125,0,0,0,114,194,0,0,0,114,159,0,0,0,114,201, + 0,0,0,114,4,0,0,0,114,4,0,0,0,41,1,114, + 212,0,0,0,114,6,0,0,0,114,211,0,0,0,21,3, + 0,0,115,14,0,0,0,12,3,6,2,12,6,12,4,12, + 3,24,12,18,5,114,211,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,135,0,0,0,114,136, + 0,0,0,41,3,114,41,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, + 110,0,0,0,114,37,0,0,0,114,209,0,0,0,114,4, + 0,0,0,114,4,0,0,0,114,6,0,0,0,114,198,0, + 0,0,66,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,99,0,0,0,114,199,0,0,0,41,5, + 114,110,0,0,0,114,92,0,0,0,114,91,0,0,0,114, + 55,0,0,0,114,44,0,0,0,114,4,0,0,0,114,4, + 0,0,0,114,6,0,0,0,114,200,0,0,0,71,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,221,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,40,0,0,0,114,48,0,0,0,114,165,0,0, + 0,114,35,0,0,0,114,30,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,42,0,0,0,114,107,0, + 0,0,114,57,0,0,0,41,9,114,110,0,0,0,114,37, + 0,0,0,114,55,0,0,0,114,221,0,0,0,218,6,112, + 97,114,101,110,116,114,96,0,0,0,114,29,0,0,0,114, + 25,0,0,0,114,202,0,0,0,114,4,0,0,0,114,4, + 0,0,0,114,6,0,0,0,114,199,0,0,0,76,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,114,0,0,0,114, + 113,0,0,0,114,115,0,0,0,114,116,0,0,0,114,198, + 0,0,0,114,200,0,0,0,114,199,0,0,0,114,4,0, + 0,0,114,4,0,0,0,114,4,0,0,0,114,6,0,0, + 0,114,219,0,0,0,62,3,0,0,115,8,0,0,0,12, + 2,6,2,12,5,12,5,114,219,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,108,0,0,0,114,37,0,0,0,114,91, + 0,0,0,41,4,114,159,0,0,0,114,201,0,0,0,114, + 143,0,0,0,114,149,0,0,0,41,5,114,110,0,0,0, + 114,128,0,0,0,114,37,0,0,0,114,55,0,0,0,114, + 210,0,0,0,114,4,0,0,0,114,4,0,0,0,114,6, + 0,0,0,114,188,0,0,0,109,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,110,0,0,0,114,128, + 0,0,0,114,4,0,0,0,114,4,0,0,0,114,6,0, + 0,0,114,203,0,0,0,115,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,114,0,0,0,114,113,0,0,0, + 114,115,0,0,0,114,116,0,0,0,114,188,0,0,0,114, + 203,0,0,0,114,4,0,0,0,114,4,0,0,0,114,4, + 0,0,0,114,6,0,0,0,114,224,0,0,0,105,3,0, + 0,115,6,0,0,0,12,2,6,2,12,6,114,224,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,108, + 0,0,0,114,37,0,0,0,41,3,114,110,0,0,0,114, + 108,0,0,0,114,37,0,0,0,114,4,0,0,0,114,4, + 0,0,0,114,6,0,0,0,114,186,0,0,0,132,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,212,0,0,0,114,120, + 0,0,0,41,2,114,110,0,0,0,114,213,0,0,0,114, + 4,0,0,0,114,4,0,0,0,114,6,0,0,0,114,214, + 0,0,0,136,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,215,0,0,0,114,108,0,0,0,114, + 37,0,0,0,41,1,114,110,0,0,0,114,4,0,0,0, + 114,4,0,0,0,114,6,0,0,0,114,216,0,0,0,140, + 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,123,0,0,0,114,189,0,0,0,114, + 147,0,0,0,90,14,99,114,101,97,116,101,95,100,121,110, + 97,109,105,99,114,107,0,0,0,114,108,0,0,0,114,37, + 0,0,0,41,3,114,110,0,0,0,114,166,0,0,0,114, + 191,0,0,0,114,4,0,0,0,114,4,0,0,0,114,6, + 0,0,0,114,187,0,0,0,143,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,123,0,0,0,114,189,0,0,0,114,147, + 0,0,0,90,12,101,120,101,99,95,100,121,110,97,109,105, + 99,114,107,0,0,0,114,108,0,0,0,114,37,0,0,0, + 41,2,114,110,0,0,0,114,191,0,0,0,114,4,0,0, + 0,114,4,0,0,0,114,6,0,0,0,114,192,0,0,0, + 151,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, + 31,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, + 186,0,0,0,78,114,4,0,0,0,41,2,114,24,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,6,0,0,0, + 250,9,60,103,101,110,101,120,112,114,62,160,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,40,0,0,0, + 114,37,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,110,0,0,0,114,128,0,0,0,114,4,0,0,0,41, + 1,114,227,0,0,0,114,6,0,0,0,114,161,0,0,0, + 157,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,110,0,0,0,114,128,0, + 0,0,114,4,0,0,0,114,4,0,0,0,114,6,0,0, + 0,114,188,0,0,0,163,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,110, + 0,0,0,114,128,0,0,0,114,4,0,0,0,114,4,0, + 0,0,114,6,0,0,0,114,203,0,0,0,167,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,37,0,0,0,41,2,114, + 110,0,0,0,114,128,0,0,0,114,4,0,0,0,114,4, + 0,0,0,114,6,0,0,0,114,159,0,0,0,171,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,114,0, + 0,0,114,113,0,0,0,114,115,0,0,0,114,116,0,0, + 0,114,186,0,0,0,114,214,0,0,0,114,216,0,0,0, + 114,187,0,0,0,114,192,0,0,0,114,161,0,0,0,114, + 188,0,0,0,114,203,0,0,0,114,125,0,0,0,114,159, + 0,0,0,114,4,0,0,0,114,4,0,0,0,114,4,0, + 0,0,114,6,0,0,0,114,225,0,0,0,124,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,225,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,95,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,110,0,0,0,114,108,0,0,0,114,37,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,6,0,0,0,114,186,0, + 0,0,184,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,60,0, + 0,0,114,32,0,0,0,114,8,0,0,0,114,37,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,232,0,0,0,114, + 34,0,0,0,41,4,114,110,0,0,0,114,223,0,0,0, + 218,3,100,111,116,90,2,109,101,114,4,0,0,0,114,4, + 0,0,0,114,6,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,190,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, + 239,0,0,0,114,119,0,0,0,114,8,0,0,0,218,7, + 109,111,100,117,108,101,115,41,3,114,110,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,6,0,0, + 0,114,234,0,0,0,200,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,95,0,0,0,114,234, + 0,0,0,114,235,0,0,0,114,236,0,0,0,114,232,0, + 0,0,114,129,0,0,0,114,158,0,0,0,114,233,0,0, + 0,41,3,114,110,0,0,0,90,11,112,97,114,101,110,116, + 95,112,97,116,104,114,166,0,0,0,114,4,0,0,0,114, + 4,0,0,0,114,6,0,0,0,218,12,95,114,101,99,97, + 108,99,117,108,97,116,101,204,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,241,0,0,0,41,1,114,110,0,0,0,114,4, + 0,0,0,114,4,0,0,0,114,6,0,0,0,218,8,95, + 95,105,116,101,114,95,95,217,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,33,0,0,0,114, + 241,0,0,0,41,1,114,110,0,0,0,114,4,0,0,0, + 114,4,0,0,0,114,6,0,0,0,218,7,95,95,108,101, + 110,95,95,220,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,49,0,0,0, + 114,233,0,0,0,41,1,114,110,0,0,0,114,4,0,0, + 0,114,4,0,0,0,114,6,0,0,0,218,8,95,95,114, + 101,112,114,95,95,223,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,241,0,0,0,41,2,114, + 110,0,0,0,218,4,105,116,101,109,114,4,0,0,0,114, + 4,0,0,0,114,6,0,0,0,218,12,95,95,99,111,110, + 116,97,105,110,115,95,95,226,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,233,0,0,0,114,165,0,0,0,41,2,114,110, + 0,0,0,114,246,0,0,0,114,4,0,0,0,114,4,0, + 0,0,114,6,0,0,0,114,165,0,0,0,229,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,114,0,0,0,114,113,0,0,0,114,115,0,0,0, + 114,116,0,0,0,114,186,0,0,0,114,239,0,0,0,114, + 234,0,0,0,114,241,0,0,0,114,243,0,0,0,114,244, + 0,0,0,114,245,0,0,0,114,247,0,0,0,114,165,0, + 0,0,114,4,0,0,0,114,4,0,0,0,114,4,0,0, + 0,114,6,0,0,0,114,231,0,0,0,177,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,231,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,231,0,0,0,114,233, + 0,0,0,41,4,114,110,0,0,0,114,108,0,0,0,114, + 37,0,0,0,114,237,0,0,0,114,4,0,0,0,114,4, + 0,0,0,114,6,0,0,0,114,186,0,0,0,235,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,49,0,0,0,114,114,0,0,0,41,2,114,172,0, + 0,0,114,191,0,0,0,114,4,0,0,0,114,4,0,0, + 0,114,6,0,0,0,218,11,109,111,100,117,108,101,95,114, + 101,112,114,238,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,110,0,0,0,114,128,0,0,0,114, + 4,0,0,0,114,4,0,0,0,114,6,0,0,0,114,161, + 0,0,0,247,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,32,0,0, + 0,114,4,0,0,0,41,2,114,110,0,0,0,114,128,0, + 0,0,114,4,0,0,0,114,4,0,0,0,114,6,0,0, + 0,114,203,0,0,0,250,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,32,0,0,0,122,8,60,115,116,114,105,110,103,62, + 114,190,0,0,0,114,205,0,0,0,84,41,1,114,206,0, + 0,0,41,2,114,110,0,0,0,114,128,0,0,0,114,4, + 0,0,0,114,4,0,0,0,114,6,0,0,0,114,188,0, + 0,0,253,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,110,0,0, + 0,114,166,0,0,0,114,4,0,0,0,114,4,0,0,0, + 114,6,0,0,0,114,187,0,0,0,0,4,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,110,0,0,0, + 114,191,0,0,0,114,4,0,0,0,114,4,0,0,0,114, + 6,0,0,0,114,192,0,0,0,3,4,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,107,0,0, + 0,114,233,0,0,0,114,123,0,0,0,114,193,0,0,0, + 41,2,114,110,0,0,0,114,128,0,0,0,114,4,0,0, + 0,114,4,0,0,0,114,6,0,0,0,114,194,0,0,0, + 6,4,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,114, + 0,0,0,114,113,0,0,0,114,115,0,0,0,114,186,0, + 0,0,114,184,0,0,0,114,249,0,0,0,114,161,0,0, + 0,114,203,0,0,0,114,188,0,0,0,114,187,0,0,0, + 114,192,0,0,0,114,194,0,0,0,114,4,0,0,0,114, + 4,0,0,0,114,4,0,0,0,114,6,0,0,0,114,248, + 0,0,0,234,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,248,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,8,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,117,0,0,0,114,251,0,0,0,41,2,114, + 172,0,0,0,218,6,102,105,110,100,101,114,114,4,0,0, + 0,114,4,0,0,0,114,6,0,0,0,114,251,0,0,0, + 23,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,8,0,0,0,218,10,112,97,116,104,95,104, + 111,111,107,115,114,62,0,0,0,114,63,0,0,0,114,127, + 0,0,0,114,109,0,0,0,41,3,114,172,0,0,0,114, + 37,0,0,0,90,4,104,111,111,107,114,4,0,0,0,114, + 4,0,0,0,114,6,0,0,0,218,11,95,112,97,116,104, + 95,104,111,111,107,115,31,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,32,0,0,0,78,41,7,114,3,0,0,0,114, + 47,0,0,0,218,17,70,105,108,101,78,111,116,70,111,117, + 110,100,69,114,114,111,114,114,8,0,0,0,114,252,0,0, + 0,114,139,0,0,0,114,0,1,0,0,41,3,114,172,0, + 0,0,114,37,0,0,0,114,254,0,0,0,114,4,0,0, + 0,114,4,0,0,0,114,6,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,48,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,126,0,0,0,41,7,114,117,0,0, + 0,114,126,0,0,0,114,183,0,0,0,114,123,0,0,0, + 114,180,0,0,0,114,162,0,0,0,114,158,0,0,0,41, + 6,114,172,0,0,0,114,128,0,0,0,114,254,0,0,0, + 114,129,0,0,0,114,130,0,0,0,114,166,0,0,0,114, + 4,0,0,0,114,4,0,0,0,114,6,0,0,0,218,16, + 95,108,101,103,97,99,121,95,103,101,116,95,115,112,101,99, + 70,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,182,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,145,0,0,0,114,71,0,0,0, + 218,5,98,121,116,101,115,114,2,1,0,0,114,117,0,0, + 0,114,182,0,0,0,114,3,1,0,0,114,129,0,0,0, + 114,158,0,0,0,114,109,0,0,0,114,151,0,0,0,114, + 123,0,0,0,114,162,0,0,0,41,9,114,172,0,0,0, + 114,128,0,0,0,114,37,0,0,0,114,181,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,254,0,0,0,114,166,0,0,0, + 114,130,0,0,0,114,4,0,0,0,114,4,0,0,0,114, + 6,0,0,0,218,9,95,103,101,116,95,115,112,101,99,85, + 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,8,0,0,0,114,37,0,0,0,114,6,1,0,0,114, + 129,0,0,0,114,158,0,0,0,114,160,0,0,0,114,231, + 0,0,0,41,6,114,172,0,0,0,114,128,0,0,0,114, + 37,0,0,0,114,181,0,0,0,114,166,0,0,0,114,5, + 1,0,0,114,4,0,0,0,114,4,0,0,0,114,6,0, + 0,0,114,182,0,0,0,117,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,182,0,0,0,114,129,0,0,0,41,4, + 114,172,0,0,0,114,128,0,0,0,114,37,0,0,0,114, + 166,0,0,0,114,4,0,0,0,114,4,0,0,0,114,6, + 0,0,0,114,183,0,0,0,139,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,114,0,0,0,114,113,0,0,0,114,115,0, + 0,0,114,116,0,0,0,114,184,0,0,0,114,251,0,0, + 0,114,0,1,0,0,114,2,1,0,0,114,3,1,0,0, + 114,6,1,0,0,114,182,0,0,0,114,183,0,0,0,114, + 4,0,0,0,114,4,0,0,0,114,4,0,0,0,114,6, + 0,0,0,114,250,0,0,0,19,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,250,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,24,0,0,0,114,226,0, + 0,0,41,1,114,129,0,0,0,114,4,0,0,0,114,6, + 0,0,0,114,228,0,0,0,168,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,60,0,0,0, + 114,31,0,0,0,78,114,89,0,0,0,41,7,114,151,0, + 0,0,218,8,95,108,111,97,100,101,114,115,114,37,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,110,0,0,0,114,37,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,168,0,0,0,114, + 4,0,0,0,41,1,114,129,0,0,0,114,6,0,0,0, + 114,186,0,0,0,162,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,31,0, + 0,0,78,114,89,0,0,0,41,1,114,9,1,0,0,41, + 1,114,110,0,0,0,114,4,0,0,0,114,4,0,0,0, + 114,6,0,0,0,114,251,0,0,0,176,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,182,0,0,0,114,129,0,0,0,114,158, + 0,0,0,41,3,114,110,0,0,0,114,128,0,0,0,114, + 166,0,0,0,114,4,0,0,0,114,4,0,0,0,114,6, + 0,0,0,114,126,0,0,0,182,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,129,0,0,0,114,158,0,0,0, + 41,1,114,169,0,0,0,41,7,114,110,0,0,0,114,167, + 0,0,0,114,128,0,0,0,114,37,0,0,0,90,4,115, + 109,115,108,114,181,0,0,0,114,129,0,0,0,114,4,0, + 0,0,114,4,0,0,0,114,6,0,0,0,114,6,1,0, + 0,194,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,102,84, + 114,121,32,116,111,32,102,105,110,100,32,97,32,115,112,101, + 99,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,46,32,32,82,101,116, + 117,114,110,115,32,116,104,101,10,32,32,32,32,32,32,32, + 32,109,97,116,99,104,105,110,103,32,115,112,101,99,44,32, + 111,114,32,78,111,110,101,32,105,102,32,110,111,116,32,102, + 111,117,110,100,46,70,114,60,0,0,0,114,58,0,0,0, + 114,31,0,0,0,114,186,0,0,0,122,9,116,114,121,105, + 110,103,32,123,125,114,100,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,89,0,0,0,41,23,114,34,0, + 0,0,114,41,0,0,0,114,37,0,0,0,114,3,0,0, + 0,114,47,0,0,0,114,220,0,0,0,114,42,0,0,0, + 114,9,1,0,0,218,11,95,102,105,108,108,95,99,97,99, + 104,101,114,7,0,0,0,114,12,1,0,0,114,90,0,0, + 0,114,11,1,0,0,114,30,0,0,0,114,8,1,0,0, + 114,46,0,0,0,114,6,1,0,0,114,48,0,0,0,114, + 107,0,0,0,114,49,0,0,0,114,123,0,0,0,114,162, + 0,0,0,114,158,0,0,0,41,14,114,110,0,0,0,114, + 128,0,0,0,114,181,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,135,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,226,0,0,0,114,167, + 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,166,0, + 0,0,114,4,0,0,0,114,4,0,0,0,114,6,0,0, + 0,114,182,0,0,0,199,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,60,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,90,0,0,0,41,2,114,24,0,0,0, + 90,2,102,110,114,4,0,0,0,114,4,0,0,0,114,6, + 0,0,0,250,9,60,115,101,116,99,111,109,112,62,17,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,37,0,0,0,114,3,0,0, + 0,90,7,108,105,115,116,100,105,114,114,47,0,0,0,114, + 1,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,8,0,0,0,114,9, + 0,0,0,114,10,0,0,0,114,10,1,0,0,114,11,1, + 0,0,114,85,0,0,0,114,49,0,0,0,114,90,0,0, + 0,218,3,97,100,100,114,11,0,0,0,114,12,1,0,0, + 41,9,114,110,0,0,0,114,37,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,246,0, + 0,0,114,108,0,0,0,114,238,0,0,0,114,226,0,0, + 0,90,8,110,101,119,95,110,97,109,101,114,4,0,0,0, + 114,4,0,0,0,114,6,0,0,0,114,14,1,0,0,244, + 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,37,0,0,0,41,2,114,48,0, + 0,0,114,109,0,0,0,41,1,114,37,0,0,0,41,2, + 114,172,0,0,0,114,13,1,0,0,114,4,0,0,0,114, + 6,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,29,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,172,0,0, + 0,114,13,1,0,0,114,19,1,0,0,114,4,0,0,0, + 41,2,114,172,0,0,0,114,13,1,0,0,114,6,0,0, + 0,218,9,112,97,116,104,95,104,111,111,107,19,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,49,0,0,0,114,37,0,0,0,41,1,114,110,0,0, + 0,114,4,0,0,0,114,4,0,0,0,114,6,0,0,0, + 114,245,0,0,0,37,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,114,0,0,0,114,113,0,0, + 0,114,115,0,0,0,114,116,0,0,0,114,186,0,0,0, + 114,251,0,0,0,114,132,0,0,0,114,183,0,0,0,114, + 126,0,0,0,114,6,1,0,0,114,182,0,0,0,114,14, + 1,0,0,114,184,0,0,0,114,20,1,0,0,114,245,0, + 0,0,114,4,0,0,0,114,4,0,0,0,114,4,0,0, + 0,114,6,0,0,0,114,7,1,0,0,153,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,7,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,129,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,129,0,0,0,114,224,0,0,0,114, + 219,0,0,0,114,169,0,0,0,218,9,69,120,99,101,112, + 116,105,111,110,41,6,90,2,110,115,114,108,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,129,0,0,0,114,166,0,0,0,114,4, + 0,0,0,114,4,0,0,0,114,6,0,0,0,218,14,95, + 102,105,120,95,117,112,95,109,111,100,117,108,101,43,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,25,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,225,0,0,0,114,147,0,0,0,218,18,101, + 120,116,101,110,115,105,111,110,95,115,117,102,102,105,120,101, + 115,114,219,0,0,0,114,86,0,0,0,114,224,0,0,0, + 114,76,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, + 6,0,0,0,114,163,0,0,0,66,5,0,0,115,8,0, + 0,0,0,5,18,1,12,1,12,1,114,163,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,51,0,0,0,114,62,0,0,0,218,8,98,117,105,108, + 116,105,110,115,114,144,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,31,0,0,0,78,41,1,114, + 33,0,0,0,41,2,114,24,0,0,0,114,79,0,0,0, + 114,4,0,0,0,114,4,0,0,0,114,6,0,0,0,114, + 228,0,0,0,102,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,61,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,27,0,0,0,114,23,0,0,0,114,32, + 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, + 171,0,0,0,114,7,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, + 123,0,0,0,114,8,0,0,0,114,147,0,0,0,114,240, + 0,0,0,114,114,0,0,0,90,18,95,98,117,105,108,116, + 105,110,95,102,114,111,109,95,110,97,109,101,114,118,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,109,0,0,0,114,28,0,0,0, + 114,13,0,0,0,114,230,0,0,0,114,151,0,0,0,114, + 26,1,0,0,114,86,0,0,0,114,165,0,0,0,114,170, + 0,0,0,114,174,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,23,0,0,0,114,27,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,6,0, + 0,0,218,6,95,115,101,116,117,112,77,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,34,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,29,1,0,0,78,41,14,114,34,1, + 0,0,114,163,0,0,0,114,8,0,0,0,114,255,0,0, + 0,114,151,0,0,0,114,7,1,0,0,114,20,1,0,0, + 114,3,0,0,0,114,114,0,0,0,218,9,109,101,116,97, + 95,112,97,116,104,114,165,0,0,0,114,170,0,0,0,114, + 250,0,0,0,114,219,0,0,0,41,2,114,33,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,6,0, + 0,0,218,8,95,105,110,115,116,97,108,108,145,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,36,1,0,0,41,1,122,3,119,105, + 110,41,2,114,1,0,0,0,114,2,0,0,0,41,59,114, + 116,0,0,0,114,12,0,0,0,90,37,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,95,66,89,84,69,83,95,75,69,89, + 114,11,0,0,0,114,13,0,0,0,114,19,0,0,0,114, + 21,0,0,0,114,30,0,0,0,114,40,0,0,0,114,41, + 0,0,0,114,45,0,0,0,114,46,0,0,0,114,48,0, + 0,0,114,57,0,0,0,218,4,116,121,112,101,218,8,95, + 95,99,111,100,101,95,95,114,146,0,0,0,114,17,0,0, + 0,114,137,0,0,0,114,16,0,0,0,114,20,0,0,0, + 90,17,95,82,65,87,95,77,65,71,73,67,95,78,85,77, + 66,69,82,114,75,0,0,0,114,74,0,0,0,114,86,0, + 0,0,114,76,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,81,0, + 0,0,114,87,0,0,0,114,93,0,0,0,114,97,0,0, + 0,114,99,0,0,0,114,107,0,0,0,114,125,0,0,0, + 114,132,0,0,0,114,143,0,0,0,114,149,0,0,0,114, + 152,0,0,0,114,157,0,0,0,218,6,111,98,106,101,99, + 116,114,164,0,0,0,114,169,0,0,0,114,170,0,0,0, + 114,185,0,0,0,114,195,0,0,0,114,211,0,0,0,114, + 219,0,0,0,114,224,0,0,0,114,230,0,0,0,114,225, + 0,0,0,114,231,0,0,0,114,248,0,0,0,114,250,0, + 0,0,114,7,1,0,0,114,25,1,0,0,114,163,0,0, + 0,114,34,1,0,0,114,36,1,0,0,114,4,0,0,0, + 114,4,0,0,0,114,4,0,0,0,114,6,0,0,0,218, + 8,60,109,111,100,117,108,101,62,8,0,0,0,115,106,0, + 0,0,6,16,6,1,6,1,3,1,7,3,12,17,12,5, + 12,5,12,6,12,12,12,10,12,9,12,5,12,7,15,22, + 15,114,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 6f0ee5e..5b8de99 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) { @@ -1585,7 +1644,7 @@ The file must be an open file object such as sys.stdout or returned by\n\ open() or os.popen(). It must be opened in binary mode ('wb' or 'w+b').\n\ \n\ If the value has (or contains an object that has) an unsupported type, a\n\ -ValueError exception is raised — but garbage data will also be written\n\ +ValueError exception is raised - but garbage data will also be written\n\ to the file. The object will not be properly read back by load()\n\ \n\ The version argument indicates the data format that dump should use."); @@ -1636,7 +1695,7 @@ PyDoc_STRVAR(load_doc, "load(file)\n\ \n\ Read one value from the open file and return it. If no valid value is\n\ -read (e.g. because the data has a different Python version’s\n\ +read (e.g. because the data has a different Python version's\n\ incompatible marshal format), raise EOFError, ValueError or TypeError.\n\ The file must be an open file object opened in binary mode ('rb' or\n\ 'r+b').\n\ diff --git a/Python/modsupport.c b/Python/modsupport.c index 6c938dd..0d09371 100644 --- a/Python/modsupport.c +++ b/Python/modsupport.c @@ -63,48 +63,84 @@ static PyObject *do_mkdict(const char**, va_list *, int, int, int); static PyObject *do_mkvalue(const char**, va_list *, int); +static void +do_ignore(const char **p_format, va_list *p_va, int endchar, int n, int flags) +{ + PyObject *v; + int i; + assert(PyErr_Occurred()); + v = PyTuple_New(n); + for (i = 0; i < n; i++) { + PyObject *exception, *value, *tb, *w; + + PyErr_Fetch(&exception, &value, &tb); + w = do_mkvalue(p_format, p_va, flags); + PyErr_Restore(exception, value, tb); + if (w != NULL) { + if (v != NULL) { + PyTuple_SET_ITEM(v, i, w); + } + else { + Py_DECREF(w); + } + } + } + Py_XDECREF(v); + if (**p_format != endchar) { + PyErr_SetString(PyExc_SystemError, + "Unmatched paren in format"); + return; + } + if (endchar) + ++*p_format; +} + static PyObject * do_mkdict(const char **p_format, va_list *p_va, int endchar, int n, int flags) { PyObject *d; int i; - int itemfailed = 0; if (n < 0) return NULL; - if ((d = PyDict_New()) == NULL) + if (n % 2) { + PyErr_SetString(PyExc_SystemError, + "Bad dict format"); + do_ignore(p_format, p_va, endchar, n, flags); return NULL; + } /* Note that we can't bail immediately on error as this will leak refcounts on any 'N' arguments. */ + if ((d = PyDict_New()) == NULL) { + do_ignore(p_format, p_va, endchar, n, flags); + return NULL; + } for (i = 0; i < n; i+= 2) { PyObject *k, *v; - int err; + k = do_mkvalue(p_format, p_va, flags); if (k == NULL) { - itemfailed = 1; - Py_INCREF(Py_None); - k = Py_None; + do_ignore(p_format, p_va, endchar, n - i - 1, flags); + Py_DECREF(d); + return NULL; } v = do_mkvalue(p_format, p_va, flags); - if (v == NULL) { - itemfailed = 1; - Py_INCREF(Py_None); - v = Py_None; - } - err = PyDict_SetItem(d, k, v); - Py_DECREF(k); - Py_DECREF(v); - if (err < 0 || itemfailed) { + if (v == NULL || PyDict_SetItem(d, k, v) < 0) { + do_ignore(p_format, p_va, endchar, n - i - 2, flags); + Py_DECREF(k); + Py_XDECREF(v); Py_DECREF(d); return NULL; } + Py_DECREF(k); + Py_DECREF(v); } - if (d != NULL && **p_format != endchar) { + if (**p_format != endchar) { Py_DECREF(d); - d = NULL; PyErr_SetString(PyExc_SystemError, "Unmatched paren in format"); + return NULL; } - else if (endchar) + if (endchar) ++*p_format; return d; } @@ -114,29 +150,24 @@ do_mklist(const char **p_format, va_list *p_va, int endchar, int n, int flags) { PyObject *v; int i; - int itemfailed = 0; if (n < 0) return NULL; - v = PyList_New(n); - if (v == NULL) - return NULL; /* Note that we can't bail immediately on error as this will leak refcounts on any 'N' arguments. */ + v = PyList_New(n); + if (v == NULL) { + do_ignore(p_format, p_va, endchar, n, flags); + return NULL; + } for (i = 0; i < n; i++) { PyObject *w = do_mkvalue(p_format, p_va, flags); if (w == NULL) { - itemfailed = 1; - Py_INCREF(Py_None); - w = Py_None; + do_ignore(p_format, p_va, endchar, n - i - 1, flags); + Py_DECREF(v); + return NULL; } PyList_SET_ITEM(v, i, w); } - - if (itemfailed) { - /* do_mkvalue() should have already set an error */ - Py_DECREF(v); - return NULL; - } if (**p_format != endchar) { Py_DECREF(v); PyErr_SetString(PyExc_SystemError, @@ -153,37 +184,23 @@ do_mktuple(const char **p_format, va_list *p_va, int endchar, int n, int flags) { PyObject *v; int i; - int itemfailed = 0; if (n < 0) return NULL; - if ((v = PyTuple_New(n)) == NULL) - return NULL; /* Note that we can't bail immediately on error as this will leak refcounts on any 'N' arguments. */ + if ((v = PyTuple_New(n)) == NULL) { + do_ignore(p_format, p_va, endchar, n, flags); + return NULL; + } for (i = 0; i < n; i++) { - PyObject *w; - - if (itemfailed) { - PyObject *exception, *value, *tb; - PyErr_Fetch(&exception, &value, &tb); - w = do_mkvalue(p_format, p_va, flags); - PyErr_Restore(exception, value, tb); - } - else { - w = do_mkvalue(p_format, p_va, flags); - } + PyObject *w = do_mkvalue(p_format, p_va, flags); if (w == NULL) { - itemfailed = 1; - Py_INCREF(Py_None); - w = Py_None; + do_ignore(p_format, p_va, endchar, n - i - 1, flags); + Py_DECREF(v); + return NULL; } PyTuple_SET_ITEM(v, i, w); } - if (itemfailed) { - /* do_mkvalue() should have already set an error */ - Py_DECREF(v); - return NULL; - } if (**p_format != endchar) { Py_DECREF(v); PyErr_SetString(PyExc_SystemError, diff --git a/Python/opcode_targets.h b/Python/opcode_targets.h index f90a17a..19259e1 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 c56c8fc..4e657fa 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; @@ -339,7 +344,7 @@ markblocks(unsigned char *code, Py_ssize_t len) appear before MAKE_FUNCTION; in this case both opcodes are skipped. EXTENDED_ARG preceding any other opcode causes the optimizer to bail. - Optimizations are restricted to simple transformations occuring within a + Optimizations are restricted to simple transformations occurring within a single basic block. All transformations keep the code size the same or smaller. For those that reduce size, the gaps are initially filled with NOPs. Later those NOPs are removed and the jump addresses retargeted in @@ -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 4b7f5ba..ab0ef83 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 0000000..ce52990 --- /dev/null +++ b/Python/pylifecycle.c @@ -0,0 +1,1597 @@ +/* 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) { + 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; + } + } + if (!errors && !(pythonioencoding && *pythonioencoding)) { + /* 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"; + } + } + + /* 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; +} + + +static void +_Py_FatalError_DumpTracebacks(int fd) +{ + PyThreadState *tstate; + +#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 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. + + Return 1 if the traceback was displayed, 0 otherwise. */ + +static int +_Py_FatalError_PrintExc(int fd) +{ + PyObject *ferr, *res; + PyObject *exception, *v, *tb; + int has_tb; + + if (PyThreadState_GET() == NULL) { + /* The GIL is released: trying to acquire it is likely to deadlock, + just give up. */ + return 0; + } + + PyErr_Fetch(&exception, &v, &tb); + if (exception == NULL) { + /* No current exception */ + return 0; + } + + 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 */ + return 0; + } + + PyErr_NormalizeException(&exception, &v, &tb); + if (tb == NULL) { + tb = Py_None; + Py_INCREF(tb); + } + PyException_SetTraceback(v, tb); + if (exception == NULL) { + /* PyErr_NormalizeException() failed */ + return 0; + } + + 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); + + return has_tb; +} + +/* 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. */ + if (!_Py_FatalError_PrintExc(fd)) + _Py_FatalError_DumpTracebacks(fd); + + /* 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(); + + /* Check if the current Python thread hold the GIL */ + if (PyThreadState_GET() != NULL) { + /* Flush sys.stdout and sys.stderr */ + flush_std_files(); + } + +#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 2ac2fd5..6d1c6d0 100644 --- a/Python/pystate.c +++ b/Python/pystate.c @@ -3,6 +3,14 @@ #include "Python.h" +#define GET_TSTATE() \ + ((PyThreadState*)_Py_atomic_load_relaxed(&_PyThreadState_Current)) +#define SET_TSTATE(value) \ + _Py_atomic_store_relaxed(&_PyThreadState_Current, (Py_uintptr_t)(value)) +#define GET_INTERP_STATE() \ + (GET_TSTATE()->interp) + + /* -------------------------------------------------------------------------- CAUTION @@ -48,7 +56,7 @@ static PyInterpreterState *interp_head = NULL; /* Assuming the current thread holds the GIL, this is the PyThreadState for the current thread. */ -_Py_atomic_address _PyThreadState_Current = {NULL}; +_Py_atomic_address _PyThreadState_Current = {0}; PyThreadFrameGetter _PyThreadState_GetFrame = NULL; #ifdef WITH_THREAD @@ -212,6 +220,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); @@ -251,8 +262,11 @@ PyObject* PyState_FindModule(struct PyModuleDef* module) { Py_ssize_t index = module->m_base.m_index; - PyInterpreterState *state = PyThreadState_GET()->interp; + PyInterpreterState *state = GET_INTERP_STATE(); PyObject *res; + if (module->m_slots) { + return NULL; + } if (index == 0) return NULL; if (state->modules_by_index == NULL) @@ -266,7 +280,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 = GET_INTERP_STATE(); if (!def) return -1; if (!state->modules_by_index) { @@ -286,7 +306,7 @@ int PyState_AddModule(PyObject* module, struct PyModuleDef* def) { Py_ssize_t index; - PyInterpreterState *state = PyThreadState_GET()->interp; + PyInterpreterState *state = GET_INTERP_STATE(); if (!def) { Py_FatalError("PyState_AddModule: Module Definition is NULL"); return -1; @@ -306,8 +326,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 = GET_INTERP_STATE(); if (index == 0) { Py_FatalError("PyState_RemoveModule: Module index invalid."); return -1; @@ -327,7 +353,7 @@ PyState_RemoveModule(struct PyModuleDef* def) void _PyState_ClearModules(void) { - PyInterpreterState *state = PyThreadState_GET()->interp; + PyInterpreterState *state = GET_INTERP_STATE(); if (state->modules_by_index) { Py_ssize_t i; for (i = 0; i < PyList_GET_SIZE(state->modules_by_index); i++) { @@ -372,6 +398,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 +431,7 @@ tstate_delete_common(PyThreadState *tstate) void PyThreadState_Delete(PyThreadState *tstate) { - if (tstate == _Py_atomic_load_relaxed(&_PyThreadState_Current)) + if (tstate == GET_TSTATE()) Py_FatalError("PyThreadState_Delete: tstate is still current"); #ifdef WITH_THREAD if (autoInterpreterState && PyThread_get_key_value(autoTLSkey) == tstate) @@ -417,12 +445,11 @@ PyThreadState_Delete(PyThreadState *tstate) void PyThreadState_DeleteCurrent() { - PyThreadState *tstate = (PyThreadState*)_Py_atomic_load_relaxed( - &_PyThreadState_Current); + PyThreadState *tstate = GET_TSTATE(); if (tstate == NULL) Py_FatalError( "PyThreadState_DeleteCurrent: no current tstate"); - _Py_atomic_store_relaxed(&_PyThreadState_Current, NULL); + SET_TSTATE(NULL); if (autoInterpreterState && PyThread_get_key_value(autoTLSkey) == tstate) PyThread_delete_key_value(autoTLSkey); tstate_delete_common(tstate); @@ -469,10 +496,16 @@ _PyThreadState_DeleteExcept(PyThreadState *tstate) PyThreadState * +_PyThreadState_UncheckedGet(void) +{ + return GET_TSTATE(); +} + + +PyThreadState * PyThreadState_Get(void) { - PyThreadState *tstate = (PyThreadState*)_Py_atomic_load_relaxed( - &_PyThreadState_Current); + PyThreadState *tstate = GET_TSTATE(); if (tstate == NULL) Py_FatalError("PyThreadState_Get: no current thread"); @@ -483,10 +516,9 @@ PyThreadState_Get(void) PyThreadState * PyThreadState_Swap(PyThreadState *newts) { - PyThreadState *oldts = (PyThreadState*)_Py_atomic_load_relaxed( - &_PyThreadState_Current); + PyThreadState *oldts = GET_TSTATE(); - _Py_atomic_store_relaxed(&_PyThreadState_Current, newts); + SET_TSTATE(newts); /* It should not be possible for more than one thread state to be used for a thread. Check this the best we can in debug builds. @@ -515,8 +547,7 @@ PyThreadState_Swap(PyThreadState *newts) PyObject * PyThreadState_GetDict(void) { - PyThreadState *tstate = (PyThreadState*)_Py_atomic_load_relaxed( - &_PyThreadState_Current); + PyThreadState *tstate = GET_TSTATE(); if (tstate == NULL) return NULL; @@ -540,8 +571,7 @@ PyThreadState_GetDict(void) int PyThreadState_SetAsyncExc(long id, PyObject *exc) { - PyThreadState *tstate = PyThreadState_GET(); - PyInterpreterState *interp = tstate->interp; + PyInterpreterState *interp = GET_INTERP_STATE(); PyThreadState *p; /* Although the GIL is held, a few C API functions can be called @@ -662,7 +692,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 == GET_TSTATE(); } /* Internal initialization/finalization functions called by @@ -754,9 +784,7 @@ PyGILState_GetThisThreadState(void) int PyGILState_Check(void) { - /* can't use PyThreadState_Get() since it will assert that it has the GIL */ - PyThreadState *tstate = (PyThreadState*)_Py_atomic_load_relaxed( - &_PyThreadState_Current); + PyThreadState *tstate = GET_TSTATE(); return tstate && (tstate == PyGILState_GetThisThreadState()); } diff --git a/Python/pystrhex.c b/Python/pystrhex.c new file mode 100644 index 0000000..1259ed1 --- /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 0967a47..7fbf06e 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'); @@ -1971,8 +766,11 @@ print_exception(PyObject *f, PyObject *value) /* only print colon if the str() of the object is not the empty string */ - if (s == NULL) + if (s == NULL) { + PyErr_Clear(); err = -1; + PyFile_WriteString(": <exception str() failed>", f); + } else if (!PyUnicode_Check(s) || PyUnicode_GetLength(s) != 0) err = PyFile_WriteString(": ", f); @@ -1981,6 +779,9 @@ print_exception(PyObject *f, PyObject *value) Py_XDECREF(s); } /* try to write a newline in any case */ + if (err < 0) { + PyErr_Clear(); + } err += PyFile_WriteString("\n", f); Py_XDECREF(tb); Py_DECREF(value); @@ -2188,13 +989,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 +1387,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,74 +1425,7 @@ 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 */ +/* Deprecated C API functions still provided for binary compatibility */ #undef PyParser_SimpleParseFile PyAPI_FUNC(node *) diff --git a/Python/pytime.c b/Python/pytime.c index de6a41f..7f65824 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 af3d0bd..3119872 100644 --- a/Python/random.c +++ b/Python/random.c @@ -1,11 +1,19 @@ #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_LINUX_RANDOM_H +# include <linux/random.h> +# endif +# ifdef HAVE_GETRANDOM +# include <sys/random.h> +# elif defined(HAVE_GETRANDOM_SYSCALL) +# include <sys/syscall.h> +# endif #endif #ifdef Py_DEBUG @@ -67,7 +75,7 @@ win32_urandom(unsigned char *buffer, Py_ssize_t size, int raise) return 0; } -/* Issue #25003: Don' use getentropy() on Solaris (available since +/* Issue #25003: Don't 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 +115,109 @@ py_getentropy(unsigned char *buffer, Py_ssize_t size, int fatal) } #else + +#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; + + /* getrandom() on Linux will block if called before the kernel has + * initialized the urandom entropy pool. This will cause Python + * to hang on startup if called very early in the boot process - + * see https://bugs.python.org/issue26839. To avoid this, use the + * GRND_NONBLOCK flag. */ + const int flags = GRND_NONBLOCK; + long n; + + if (!getrandom_works) + return 0; + + while (0 < size) { +#ifdef sun + /* Issue #26735: On Solaris, getrandom() is limited to returning up + to 1024 bytes */ + n = Py_MIN(size, 1024); +#else + n = Py_MIN(size, LONG_MAX); +#endif + + errno = 0; +#ifdef HAVE_GETRANDOM + if (raise) { + Py_BEGIN_ALLOW_THREADS + n = getrandom(buffer, n, flags); + Py_END_ALLOW_THREADS + } + else { + n = getrandom(buffer, n, 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, n, flags); + Py_END_ALLOW_THREADS + } + else { + n = syscall(SYS_getrandom, buffer, n, flags); + } +#endif + + if (n < 0) { + if (errno == ENOSYS) { + getrandom_works = 0; + return 0; + } + if (errno == EAGAIN) { + /* If we failed with EAGAIN, the entropy pool was + * uninitialized. In this case, we return failure to fall + * back to reading from /dev/urandom. + * + * Note: In this case the data read will not be random so + * should not be used for cryptographic purposes. Retaining + * the existing semantics for practical purposes. */ + 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 +228,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"); @@ -139,7 +251,7 @@ dev_urandom_noraise(unsigned char *buffer, Py_ssize_t size) break; } buffer += n; - size -= (Py_ssize_t)n; + size -= n; } close(fd); } @@ -151,14 +263,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 +295,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 +311,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 +323,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 +350,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 9512673..1591a20 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; @@ -371,15 +368,20 @@ error_at_directive(PySTEntryObject *ste, PyObject *name) Py_ssize_t i; PyObject *data; assert(ste->ste_directives); - for (i = 0; ; i++) { + for (i = 0; i < PyList_GET_SIZE(ste->ste_directives); i++) { data = PyList_GET_ITEM(ste->ste_directives, i); assert(PyTuple_CheckExact(data)); - if (PyTuple_GET_ITEM(data, 0) == name) - break; + assert(PyUnicode_CheckExact(PyTuple_GET_ITEM(data, 0))); + if (PyUnicode_Compare(PyTuple_GET_ITEM(data, 0), name) == 0) { + PyErr_SyntaxLocationObject(ste->ste_table->st_filename, + PyLong_AsLong(PyTuple_GET_ITEM(data, 1)), + PyLong_AsLong(PyTuple_GET_ITEM(data, 2))); + + return 0; + } } - PyErr_SyntaxLocationObject(ste->ste_table->st_filename, - PyLong_AsLong(PyTuple_GET_ITEM(data, 1)), - PyLong_AsLong(PyTuple_GET_ITEM(data, 2))); + PyErr_SetString(PyExc_RuntimeError, + "BUG: internal directive bookkeeping broken"); return 0; } @@ -852,7 +854,7 @@ analyze_child_block(PySTEntryObject *entry, PyObject *bound, PyObject *free, /* Copy the bound and global dictionaries. - These dictionary are used by all blocks enclosed by the + These dictionaries are used by all blocks enclosed by the current block. The analyze_block() call modifies these dictionaries. @@ -1086,13 +1088,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); \ } \ } @@ -1118,14 +1120,17 @@ symtable_new_tmpname(struct symtable *st) static int symtable_record_directive(struct symtable *st, identifier name, stmt_ty s) { - PyObject *data; + PyObject *data, *mangled; int res; if (!st->st_cur->ste_directives) { st->st_cur->ste_directives = PyList_New(0); if (!st->st_cur->ste_directives) return 0; } - data = Py_BuildValue("(Oii)", name, s->lineno, s->col_offset); + mangled = _Py_Mangle(st->st_private, name); + if (!mangled) + return 0; + data = Py_BuildValue("(Nii)", mangled, s->lineno, s->col_offset); if (!data) return 0; res = PyList_Append(st->st_cur->ste_directives, data); @@ -1138,7 +1143,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 +1154,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 +1175,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 +1246,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 +1324,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 +1365,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 +1386,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 +1403,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 +1434,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 +1445,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 +1538,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 +1549,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 +1635,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 290eec1..8d7e05a 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 */ }; @@ -1309,7 +1397,7 @@ error: Py_XDECREF(name); Py_XDECREF(value); /* No return value, therefore clear error state if possible */ - if (_Py_atomic_load_relaxed(&_PyThreadState_Current)) + if (_PyThreadState_UncheckedGet()) PyErr_Clear(); } @@ -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 810691f..63eeb1e 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 d2b78c5..ea96f9c 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_nt.h b/Python/thread_nt.h index 84452cd..b29b1b6 100644 --- a/Python/thread_nt.h +++ b/Python/thread_nt.h @@ -231,7 +231,7 @@ PyThread_start_new_thread(void (*func)(void *), void *arg) } /* - * Return the thread Id instead of an handle. The Id is said to uniquely identify the + * Return the thread Id instead of a handle. The Id is said to uniquely identify the * thread in the system */ long diff --git a/Python/thread_pthread.h b/Python/thread_pthread.h index d9f7c76..27e0dc8 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 7d1fc2e..941d1cb 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; } |