diff --git "a/cpython_chunk_2.py" "b/cpython_chunk_2.py" new file mode 100644--- /dev/null +++ "b/cpython_chunk_2.py" @@ -0,0 +1,15438 @@ +# Auto-generated from cpython_chunk_2.txt + +TEXT_DATA = r""" +/* Frame object implementation */ +#include "Python.h" +#include "pycore_cell.h" // PyCell_GetRef() +#include "pycore_ceval.h" // _PyEval_SetOpcodeTrace() +#include "pycore_code.h" // CO_FAST_LOCAL +#include "pycore_dict.h" // _PyDict_LoadBuiltinsFromGlobals() +#include "pycore_frame.h" // PyFrameObject +#include "pycore_function.h" // _PyFunction_FromConstructor() +#include "pycore_genobject.h" // _PyGen_GetGeneratorFromFrame() +#include "pycore_interpframe.h" // _PyFrame_GetLocalsArray() +#include "pycore_modsupport.h" // _PyArg_CheckPositional() +#include "pycore_object.h" // _PyObject_GC_UNTRACK() +#include "pycore_opcode_metadata.h" // _PyOpcode_Caches +#include "pycore_optimizer.h" // _Py_Executors_InvalidateDependency() +#include "pycore_unicodeobject.h" // _PyUnicode_Equal() +#include "frameobject.h" // PyFrameLocalsProxyObject +#include "opcode.h" // EXTENDED_ARG +#include "clinic/frameobject.c.h" +#define PyFrameObject_CAST(op) \ +(assert(PyObject_TypeCheck((op), &PyFrame_Type)), (PyFrameObject *)(op)) +#define PyFrameLocalsProxyObject_CAST(op) \ +( \ +assert(PyObject_TypeCheck((op), &PyFrameLocalsProxy_Type)), \ +(PyFrameLocalsProxyObject *)(op) \ +) +#define OFF(x) offsetof(PyFrameObject, x) +/*[clinic input] +class frame "PyFrameObject *" "&PyFrame_Type" +[clinic start generated code]*/ +/*[clinic end generated code: output=da39a3ee5e6b4b0d input=2d1dbf2e06cf351f]*/ +// Returns new reference or NULL +static PyObject * +framelocalsproxy_getval(_PyInterpreterFrame *frame, PyCodeObject *co, int i) +{ +_PyStackRef *fast = _PyFrame_GetLocalsArray(frame); +_PyLocals_Kind kind = _PyLocals_GetKind(co->co_localspluskinds, i); +PyObject *value = PyStackRef_AsPyObjectBorrow(fast[i]); +PyObject *cell = NULL; +if (value == NULL) { +return NULL; +} +if (kind == CO_FAST_FREE || kind & CO_FAST_CELL) { +// The cell was set when the frame was created from +// the function's closure. +// GH-128396: With PEP 709, it's possible to have a fast variable in +// an inlined comprehension that has the same name as the cell variable +// in the frame, where the `kind` obtained from frame can not guarantee +// that the variable is a cell. +// If the variable is not a cell, we are okay with it and we can simply +// return the value. +if (PyCell_Check(value)) { +cell = value; +} +} +if (cell != NULL) { +value = PyCell_GetRef((PyCellObject *)cell); +} +else { +Py_XINCREF(value); +} +if (value == NULL) { +return NULL; +} +return value; +} +static bool +framelocalsproxy_hasval(_PyInterpreterFrame *frame, PyCodeObject *co, int i) +{ +PyObject *value = framelocalsproxy_getval(frame, co, i); +if (value == NULL) { +return false; +} +Py_DECREF(value); +return true; +} +static int +framelocalsproxy_getkeyindex(PyFrameObject *frame, PyObject *key, bool read, PyObject **value_ptr) +{ +/* +* Returns -2 (!) if an error occurred; exception will be set. +* Returns the fast locals index of the key on success: +* - if read == true, returns the index if the value is not NULL +* - if read == false, returns the index if the value is not hidden +* Otherwise returns -1. +* +* If read == true and value_ptr is not NULL, *value_ptr is set to +* the value of the key if it is found (with a new reference). +*/ +// value_ptr should only be given if we are reading the value +assert(read || value_ptr == NULL); +PyCodeObject *co = _PyFrame_GetCode(frame->f_frame); +// Ensure that the key is hashable. +Py_hash_t key_hash = PyObject_Hash(key); +if (key_hash == -1) { +return -2; +} +bool found = false; +// We do 2 loops here because it's highly possible the key is interned +// and we can do a pointer comparison. +for (int i = 0; i < co->co_nlocalsplus; i++) { +PyObject *name = PyTuple_GET_ITEM(co->co_localsplusnames, i); +if (name == key) { +if (read) { +PyObject *value = framelocalsproxy_getval(frame->f_frame, co, i); +if (value != NULL) { +if (value_ptr != NULL) { +*value_ptr = value; +} +else { +Py_DECREF(value); +} +return i; +} +} else { +if (!(_PyLocals_GetKind(co->co_localspluskinds, i) & CO_FAST_HIDDEN)) { +return i; +} +} +found = true; +} +} +if (found) { +// This is an attempt to read an unset local variable or +// write to a variable that is hidden from regular write operations +return -1; +} +// This is unlikely, but we need to make sure. This means the key +// is not interned. +for (int i = 0; i < co->co_nlocalsplus; i++) { +PyObject *name = PyTuple_GET_ITEM(co->co_localsplusnames, i); +Py_hash_t name_hash = PyObject_Hash(name); +assert(name_hash != -1); // keys are exact unicode +if (name_hash != key_hash) { +continue; +} +int same = PyObject_RichCompareBool(name, key, Py_EQ); +if (same < 0) { +return -2; +} +if (same) { +if (read) { +PyObject *value = framelocalsproxy_getval(frame->f_frame, co, i); +if (value != NULL) { +if (value_ptr != NULL) { +*value_ptr = value; +} +else { +Py_DECREF(value); +} +return i; +} +} else { +if (!(_PyLocals_GetKind(co->co_localspluskinds, i) & CO_FAST_HIDDEN)) { +return i; +} +} +} +} +return -1; +} +static PyObject * +framelocalsproxy_getitem(PyObject *self, PyObject *key) +{ +PyFrameObject *frame = PyFrameLocalsProxyObject_CAST(self)->frame; +PyObject *value = NULL; +int i = framelocalsproxy_getkeyindex(frame, key, true, &value); +if (i == -2) { +return NULL; +} +if (i >= 0) { +assert(value != NULL); +return value; +} +assert(value == NULL); +// Okay not in the fast locals, try extra locals +PyObject *extra = frame->f_extra_locals; +if (extra != NULL) { +if (PyDict_GetItemRef(extra, key, &value) < 0) { +return NULL; +} +if (value != NULL) { +return value; +} +} +PyErr_Format(PyExc_KeyError, "local variable '%R' is not defined", key); +return NULL; +} +static int +add_overwritten_fast_local(PyFrameObject *frame, PyObject *obj) +{ +Py_ssize_t new_size; +if (frame->f_overwritten_fast_locals == NULL) { +new_size = 1; +} +else { +Py_ssize_t size = PyTuple_Size(frame->f_overwritten_fast_locals); +if (size == -1) { +return -1; +} +new_size = size + 1; +} +PyObject *new_tuple = PyTuple_New(new_size); +if (new_tuple == NULL) { +return -1; +} +for (Py_ssize_t i = 0; i < new_size - 1; i++) { +PyObject *o = PyTuple_GET_ITEM(frame->f_overwritten_fast_locals, i); +PyTuple_SET_ITEM(new_tuple, i, Py_NewRef(o)); +} +PyTuple_SET_ITEM(new_tuple, new_size - 1, Py_NewRef(obj)); +Py_XSETREF(frame->f_overwritten_fast_locals, new_tuple); +return 0; +} +static int +framelocalsproxy_setitem(PyObject *self, PyObject *key, PyObject *value) +{ +/* Merge locals into fast locals */ +PyFrameObject *frame = PyFrameLocalsProxyObject_CAST(self)->frame; +_PyStackRef *fast = _PyFrame_GetLocalsArray(frame->f_frame); +PyCodeObject *co = _PyFrame_GetCode(frame->f_frame); +int i = framelocalsproxy_getkeyindex(frame, key, false, NULL); +if (i == -2) { +return -1; +} +if (i >= 0) { +if (value == NULL) { +PyErr_SetString(PyExc_ValueError, "cannot remove local variables from FrameLocalsProxy"); +return -1; +} +#if _Py_TIER2 +_Py_Executors_InvalidateDependency(_PyInterpreterState_GET(), co, 1); +_PyJit_Tracer_InvalidateDependency(_PyThreadState_GET(), co); +#endif +_PyLocals_Kind kind = _PyLocals_GetKind(co->co_localspluskinds, i); +_PyStackRef oldvalue = fast[i]; +PyObject *cell = NULL; +if (kind == CO_FAST_FREE) { +// The cell was set when the frame was created from +// the function's closure. +assert(!PyStackRef_IsNull(oldvalue) && PyCell_Check(PyStackRef_AsPyObjectBorrow(oldvalue))); +cell = PyStackRef_AsPyObjectBorrow(oldvalue); +} else if (kind & CO_FAST_CELL && !PyStackRef_IsNull(oldvalue)) { +PyObject *as_obj = PyStackRef_AsPyObjectBorrow(oldvalue); +if (PyCell_Check(as_obj)) { +cell = as_obj; +} +} +if (cell != NULL) { +Py_XINCREF(value); +PyCell_SetTakeRef((PyCellObject *)cell, value); +} else if (value != PyStackRef_AsPyObjectBorrow(oldvalue)) { +PyObject *old_obj = PyStackRef_AsPyObjectBorrow(fast[i]); +if (old_obj != NULL && !_Py_IsImmortal(old_obj)) { +if (add_overwritten_fast_local(frame, old_obj) < 0) { +return -1; +} +PyStackRef_CLOSE(fast[i]); +} +fast[i] = PyStackRef_FromPyObjectNew(value); +} +return 0; +} +// Okay not in the fast locals, try extra locals +PyObject *extra = frame->f_extra_locals; +if (extra == NULL) { +if (value == NULL) { +_PyErr_SetKeyError(key); +return -1; +} +extra = PyDict_New(); +if (extra == NULL) { +return -1; +} +frame->f_extra_locals = extra; +} +assert(PyDict_Check(extra)); +if (value == NULL) { +return PyDict_DelItem(extra, key); +} else { +return PyDict_SetItem(extra, key, value); +} +} +static int +framelocalsproxy_merge(PyObject* self, PyObject* other) +{ +if (!PyDict_Check(other) && !PyFrameLocalsProxy_Check(other)) { +return -1; +} +PyObject *keys = PyMapping_Keys(other); +if (keys == NULL) { +return -1; +} +PyObject *iter = PyObject_GetIter(keys); +Py_DECREF(keys); +if (iter == NULL) { +return -1; +} +PyObject *key = NULL; +PyObject *value = NULL; +while ((key = PyIter_Next(iter)) != NULL) { +value = PyObject_GetItem(other, key); +if (value == NULL) { +Py_DECREF(key); +Py_DECREF(iter); +return -1; +} +if (framelocalsproxy_setitem(self, key, value) < 0) { +Py_DECREF(key); +Py_DECREF(value); +Py_DECREF(iter); +return -1; +} +Py_DECREF(key); +Py_DECREF(value); +} +Py_DECREF(iter); +if (PyErr_Occurred()) { +return -1; +} +return 0; +} +static PyObject * +framelocalsproxy_keys(PyObject *self, PyObject *Py_UNUSED(ignored)) +{ +PyFrameObject *frame = PyFrameLocalsProxyObject_CAST(self)->frame; +PyCodeObject *co = _PyFrame_GetCode(frame->f_frame); +PyObject *names = PyList_New(0); +if (names == NULL) { +return NULL; +} +for (int i = 0; i < co->co_nlocalsplus; i++) { +if (framelocalsproxy_hasval(frame->f_frame, co, i)) { +PyObject *name = PyTuple_GET_ITEM(co->co_localsplusnames, i); +if (PyList_Append(names, name) < 0) { +Py_DECREF(names); +return NULL; +} +} +} +// Iterate through the extra locals +if (frame->f_extra_locals) { +assert(PyDict_Check(frame->f_extra_locals)); +Py_ssize_t i = 0; +PyObject *key = NULL; +PyObject *value = NULL; +while (PyDict_Next(frame->f_extra_locals, &i, &key, &value)) { +if (PyList_Append(names, key) < 0) { +Py_DECREF(names); +return NULL; +} +} +} +return names; +} +static void +framelocalsproxy_dealloc(PyObject *self) +{ +PyFrameLocalsProxyObject *proxy = PyFrameLocalsProxyObject_CAST(self); +PyObject_GC_UnTrack(self); +Py_CLEAR(proxy->frame); +Py_TYPE(self)->tp_free(self); +} +static PyObject * +framelocalsproxy_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ +if (PyTuple_GET_SIZE(args) != 1) { +PyErr_Format(PyExc_TypeError, +"FrameLocalsProxy expected 1 argument, got %zd", +PyTuple_GET_SIZE(args)); +return NULL; +} +PyObject *item = PyTuple_GET_ITEM(args, 0); +if (!PyFrame_Check(item)) { +PyErr_Format(PyExc_TypeError, "expect frame, not %T", item); +return NULL; +} +PyFrameObject *frame = (PyFrameObject*)item; +if (kwds != NULL && PyDict_Size(kwds) != 0) { +PyErr_SetString(PyExc_TypeError, +"FrameLocalsProxy takes no keyword arguments"); +return 0; +} +PyFrameLocalsProxyObject *self = (PyFrameLocalsProxyObject *)type->tp_alloc(type, 0); +if (self == NULL) { +return NULL; +} +((PyFrameLocalsProxyObject*)self)->frame = (PyFrameObject*)Py_NewRef(frame); +return (PyObject *)self; +} +static int +framelocalsproxy_tp_clear(PyObject *self) +{ +PyFrameLocalsProxyObject *proxy = PyFrameLocalsProxyObject_CAST(self); +Py_CLEAR(proxy->frame); +return 0; +} +static int +framelocalsproxy_visit(PyObject *self, visitproc visit, void *arg) +{ +PyFrameLocalsProxyObject *proxy = PyFrameLocalsProxyObject_CAST(self); +Py_VISIT(proxy->frame); +return 0; +} +static PyObject * +framelocalsproxy_iter(PyObject *self) +{ +PyObject* keys = framelocalsproxy_keys(self, NULL); +if (keys == NULL) { +return NULL; +} +PyObject* iter = PyObject_GetIter(keys); +Py_XDECREF(keys); +return iter; +} +static PyObject * +framelocalsproxy_richcompare(PyObject *lhs, PyObject *rhs, int op) +{ +PyFrameLocalsProxyObject *self = PyFrameLocalsProxyObject_CAST(lhs); +if (PyFrameLocalsProxy_Check(rhs)) { +PyFrameLocalsProxyObject *other = (PyFrameLocalsProxyObject *)rhs; +bool result = self->frame == other->frame; +if (op == Py_EQ) { +return PyBool_FromLong(result); +} else if (op == Py_NE) { +return PyBool_FromLong(!result); +} +} else if (PyDict_Check(rhs)) { +PyObject *dct = PyDict_New(); +if (dct == NULL) { +return NULL; +} +if (PyDict_Update(dct, lhs) < 0) { +Py_DECREF(dct); +return NULL; +} +PyObject *result = PyObject_RichCompare(dct, rhs, op); +Py_DECREF(dct); +return result; +} +Py_RETURN_NOTIMPLEMENTED; +} +static PyObject * +framelocalsproxy_repr(PyObject *self) +{ +int i = Py_ReprEnter(self); +if (i != 0) { +return i > 0 ? PyUnicode_FromString("{...}") : NULL; +} +PyObject *dct = PyDict_New(); +if (dct == NULL) { +Py_ReprLeave(self); +return NULL; +} +if (PyDict_Update(dct, self) < 0) { +Py_DECREF(dct); +Py_ReprLeave(self); +return NULL; +} +PyObject *repr = PyObject_Repr(dct); +Py_DECREF(dct); +Py_ReprLeave(self); +return repr; +} +static PyObject* +framelocalsproxy_or(PyObject *self, PyObject *other) +{ +if (!PyDict_Check(other) && !PyFrameLocalsProxy_Check(other)) { +Py_RETURN_NOTIMPLEMENTED; +} +PyObject *result = PyDict_New(); +if (result == NULL) { +return NULL; +} +if (PyDict_Update(result, self) < 0) { +Py_DECREF(result); +return NULL; +} +if (PyDict_Update(result, other) < 0) { +Py_DECREF(result); +return NULL; +} +return result; +} +static PyObject* +framelocalsproxy_inplace_or(PyObject *self, PyObject *other) +{ +if (!PyDict_Check(other) && !PyFrameLocalsProxy_Check(other)) { +Py_RETURN_NOTIMPLEMENTED; +} +if (framelocalsproxy_merge(self, other) < 0) { +Py_RETURN_NOTIMPLEMENTED; +} +return Py_NewRef(self); +} +static PyObject * +framelocalsproxy_values(PyObject *self, PyObject *Py_UNUSED(ignored)) +{ +PyFrameObject *frame = PyFrameLocalsProxyObject_CAST(self)->frame; +PyCodeObject *co = _PyFrame_GetCode(frame->f_frame); +PyObject *values = PyList_New(0); +if (values == NULL) { +return NULL; +} +for (int i = 0; i < co->co_nlocalsplus; i++) { +PyObject *value = framelocalsproxy_getval(frame->f_frame, co, i); +if (value) { +if (PyList_Append(values, value) < 0) { +Py_DECREF(values); +Py_DECREF(value); +return NULL; +} +Py_DECREF(value); +} +} +// Iterate through the extra locals +if (frame->f_extra_locals) { +Py_ssize_t j = 0; +PyObject *key = NULL; +PyObject *value = NULL; +while (PyDict_Next(frame->f_extra_locals, &j, &key, &value)) { +if (PyList_Append(values, value) < 0) { +Py_DECREF(values); +return NULL; +} +} +} +return values; +} +static PyObject * +framelocalsproxy_items(PyObject *self, PyObject *Py_UNUSED(ignored)) +{ +PyFrameObject *frame = PyFrameLocalsProxyObject_CAST(self)->frame; +PyCodeObject *co = _PyFrame_GetCode(frame->f_frame); +PyObject *items = PyList_New(0); +if (items == NULL) { +return NULL; +} +for (int i = 0; i < co->co_nlocalsplus; i++) { +PyObject *name = PyTuple_GET_ITEM(co->co_localsplusnames, i); +PyObject *value = framelocalsproxy_getval(frame->f_frame, co, i); +if (value) { +PyObject *pair = PyTuple_Pack(2, name, value); +if (pair == NULL) { +Py_DECREF(items); +Py_DECREF(value); +return NULL; +} +if (PyList_Append(items, pair) < 0) { +Py_DECREF(items); +Py_DECREF(pair); +Py_DECREF(value); +return NULL; +} +Py_DECREF(pair); +Py_DECREF(value); +} +} +// Iterate through the extra locals +if (frame->f_extra_locals) { +Py_ssize_t j = 0; +PyObject *key = NULL; +PyObject *value = NULL; +while (PyDict_Next(frame->f_extra_locals, &j, &key, &value)) { +PyObject *pair = PyTuple_Pack(2, key, value); +if (pair == NULL) { +Py_DECREF(items); +return NULL; +} +if (PyList_Append(items, pair) < 0) { +Py_DECREF(items); +Py_DECREF(pair); +return NULL; +} +Py_DECREF(pair); +} +} +return items; +} +static Py_ssize_t +framelocalsproxy_length(PyObject *self) +{ +PyFrameObject *frame = PyFrameLocalsProxyObject_CAST(self)->frame; +PyCodeObject *co = _PyFrame_GetCode(frame->f_frame); +Py_ssize_t size = 0; +if (frame->f_extra_locals != NULL) { +assert(PyDict_Check(frame->f_extra_locals)); +size += PyDict_Size(frame->f_extra_locals); +} +for (int i = 0; i < co->co_nlocalsplus; i++) { +if (framelocalsproxy_hasval(frame->f_frame, co, i)) { +size++; +} +} +return size; +} +static int +framelocalsproxy_contains(PyObject *self, PyObject *key) +{ +PyFrameObject *frame = PyFrameLocalsProxyObject_CAST(self)->frame; +int i = framelocalsproxy_getkeyindex(frame, key, true, NULL); +if (i == -2) { +return -1; +} +if (i >= 0) { +return 1; +} +PyObject *extra = frame->f_extra_locals; +if (extra != NULL) { +return PyDict_Contains(extra, key); +} +return 0; +} +static PyObject* framelocalsproxy___contains__(PyObject *self, PyObject *key) +{ +int result = framelocalsproxy_contains(self, key); +if (result < 0) { +return NULL; +} +return PyBool_FromLong(result); +} +static PyObject* +framelocalsproxy_update(PyObject *self, PyObject *other) +{ +if (framelocalsproxy_merge(self, other) < 0) { +PyErr_SetString(PyExc_TypeError, "update() argument must be dict or another FrameLocalsProxy"); +return NULL; +} +Py_RETURN_NONE; +} +static PyObject* +framelocalsproxy_get(PyObject* self, PyObject *const *args, Py_ssize_t nargs) +{ +if (nargs < 1 || nargs > 2) { +PyErr_SetString(PyExc_TypeError, "get expected 1 or 2 arguments"); +return NULL; +} +PyObject *key = args[0]; +PyObject *default_value = Py_None; +if (nargs == 2) { +default_value = args[1]; +} +PyObject *result = framelocalsproxy_getitem(self, key); +if (result == NULL) { +if (PyErr_ExceptionMatches(PyExc_KeyError)) { +PyErr_Clear(); +return Py_XNewRef(default_value); +} +return NULL; +} +return result; +} +static PyObject* +framelocalsproxy_setdefault(PyObject* self, PyObject *const *args, Py_ssize_t nargs) +{ +if (nargs < 1 || nargs > 2) { +PyErr_SetString(PyExc_TypeError, "setdefault expected 1 or 2 arguments"); +return NULL; +} +PyObject *key = args[0]; +PyObject *default_value = Py_None; +if (nargs == 2) { +default_value = args[1]; +} +PyObject *result = framelocalsproxy_getitem(self, key); +if (result == NULL) { +if (PyErr_ExceptionMatches(PyExc_KeyError)) { +PyErr_Clear(); +if (framelocalsproxy_setitem(self, key, default_value) < 0) { +return NULL; +} +return Py_XNewRef(default_value); +} +return NULL; +} +return result; +} +static PyObject* +framelocalsproxy_pop(PyObject* self, PyObject *const *args, Py_ssize_t nargs) +{ +if (!_PyArg_CheckPositional("pop", nargs, 1, 2)) { +return NULL; +} +PyObject *key = args[0]; +PyObject *default_value = NULL; +if (nargs == 2) { +default_value = args[1]; +} +PyFrameObject *frame = PyFrameLocalsProxyObject_CAST(self)->frame; +int i = framelocalsproxy_getkeyindex(frame, key, false, NULL); +if (i == -2) { +return NULL; +} +if (i >= 0) { +PyErr_SetString(PyExc_ValueError, "cannot remove local variables from FrameLocalsProxy"); +return NULL; +} +PyObject *result = NULL; +if (frame->f_extra_locals == NULL) { +if (default_value != NULL) { +return Py_XNewRef(default_value); +} else { +_PyErr_SetKeyError(key); +return NULL; +} +} +if (PyDict_Pop(frame->f_extra_locals, key, &result) < 0) { +return NULL; +} +if (result == NULL) { +if (default_value != NULL) { +return Py_XNewRef(default_value); +} else { +_PyErr_SetKeyError(key); +return NULL; +} +} +return result; +} +static PyObject* +framelocalsproxy_copy(PyObject *self, PyObject *Py_UNUSED(ignored)) +{ +PyObject* result = PyDict_New(); +if (result == NULL) { +return NULL; +} +if (PyDict_Update(result, self) < 0) { +Py_DECREF(result); +return NULL; +} +return result; +} +static PyObject* +framelocalsproxy_reversed(PyObject *self, PyObject *Py_UNUSED(ignored)) +{ +PyObject *result = framelocalsproxy_keys(self, NULL); +if (result == NULL) { +return NULL; +} +if (PyList_Reverse(result) < 0) { +Py_DECREF(result); +return NULL; +} +return result; +} +static PyNumberMethods framelocalsproxy_as_number = { +.nb_or = framelocalsproxy_or, +.nb_inplace_or = framelocalsproxy_inplace_or, +}; +static PySequenceMethods framelocalsproxy_as_sequence = { +.sq_contains = framelocalsproxy_contains, +}; +static PyMappingMethods framelocalsproxy_as_mapping = { +.mp_length = framelocalsproxy_length, +.mp_subscript = framelocalsproxy_getitem, +.mp_ass_subscript = framelocalsproxy_setitem, +}; +static PyMethodDef framelocalsproxy_methods[] = { +{"__contains__", framelocalsproxy___contains__, METH_O | METH_COEXIST, NULL}, +{"__getitem__", framelocalsproxy_getitem, METH_O | METH_COEXIST, NULL}, +{"update", framelocalsproxy_update, METH_O, NULL}, +{"__reversed__", framelocalsproxy_reversed, METH_NOARGS, NULL}, +{"copy", framelocalsproxy_copy, METH_NOARGS, NULL}, +{"keys", framelocalsproxy_keys, METH_NOARGS, NULL}, +{"values", framelocalsproxy_values, METH_NOARGS, NULL}, +{"items", _PyCFunction_CAST(framelocalsproxy_items), METH_NOARGS, NULL}, +{"get", _PyCFunction_CAST(framelocalsproxy_get), METH_FASTCALL, NULL}, +{"pop", _PyCFunction_CAST(framelocalsproxy_pop), METH_FASTCALL, NULL}, +{ +"setdefault", +_PyCFunction_CAST(framelocalsproxy_setdefault), +METH_FASTCALL, +NULL +}, +{NULL, NULL} /* sentinel */ +}; +PyDoc_STRVAR(framelocalsproxy_doc, +"FrameLocalsProxy($frame)\n" +"--\n" +"\n" +"Create a write-through view of the locals dictionary for a frame.\n" +"\n" +" frame\n" +" the frame object to wrap."); +PyTypeObject PyFrameLocalsProxy_Type = { +PyVarObject_HEAD_INIT(&PyType_Type, 0) +.tp_name = "FrameLocalsProxy", +.tp_basicsize = sizeof(PyFrameLocalsProxyObject), +.tp_dealloc = framelocalsproxy_dealloc, +.tp_repr = &framelocalsproxy_repr, +.tp_as_number = &framelocalsproxy_as_number, +.tp_as_sequence = &framelocalsproxy_as_sequence, +.tp_as_mapping = &framelocalsproxy_as_mapping, +.tp_getattro = PyObject_GenericGetAttr, +.tp_setattro = PyObject_GenericSetAttr, +.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_MAPPING, +.tp_traverse = framelocalsproxy_visit, +.tp_clear = framelocalsproxy_tp_clear, +.tp_richcompare = framelocalsproxy_richcompare, +.tp_iter = framelocalsproxy_iter, +.tp_methods = framelocalsproxy_methods, +.tp_alloc = PyType_GenericAlloc, +.tp_new = framelocalsproxy_new, +.tp_free = PyObject_GC_Del, +.tp_doc = framelocalsproxy_doc, +}; +PyObject * +_PyFrameLocalsProxy_New(PyFrameObject *frame) +{ +PyObject* args = PyTuple_Pack(1, frame); +if (args == NULL) { +return NULL; +} +PyObject* proxy = framelocalsproxy_new(&PyFrameLocalsProxy_Type, args, NULL); +Py_DECREF(args); +return proxy; +} +static PyMemberDef frame_memberlist[] = { +{"f_trace_lines", Py_T_BOOL, OFF(f_trace_lines), 0}, +{NULL} /* Sentinel */ +}; +/*[clinic input] +@critical_section +@getter +frame.f_locals as frame_locals +Return the mapping used by the frame to look up local variables. +[clinic start generated code]*/ +static PyObject * +frame_locals_get_impl(PyFrameObject *self) +/*[clinic end generated code: output=b4ace8bb4cae71f4 input=7bd444d0dc8ddf44]*/ +{ +assert(!_PyFrame_IsIncomplete(self->f_frame)); +PyCodeObject *co = _PyFrame_GetCode(self->f_frame); +if (!(co->co_flags & CO_OPTIMIZED) && !_PyFrame_HasHiddenLocals(self->f_frame)) { +if (self->f_frame->f_locals == NULL) { +// We found cases when f_locals is NULL for non-optimized code. +// We fill the f_locals with an empty dict to avoid crash until +// we find the root cause. +self->f_frame->f_locals = PyDict_New(); +if (self->f_frame->f_locals == NULL) { +return NULL; +} +} +return Py_NewRef(self->f_frame->f_locals); +} +return _PyFrameLocalsProxy_New(self); +} +int +PyFrame_GetLineNumber(PyFrameObject *f) +{ +assert(f != NULL); +if (f->f_lineno == -1) { +// We should calculate it once. If we can't get the line number, +// set f->f_lineno to 0. +f->f_lineno = PyUnstable_InterpreterFrame_GetLine(f->f_frame); +if (f->f_lineno < 0) { +f->f_lineno = 0; +return -1; +} +} +if (f->f_lineno > 0) { +return f->f_lineno; +} +return PyUnstable_InterpreterFrame_GetLine(f->f_frame); +} +/*[clinic input] +@critical_section +@getter +frame.f_lineno as frame_lineno +Return the current line number in the frame. +[clinic start generated code]*/ +static PyObject * +frame_lineno_get_impl(PyFrameObject *self) +/*[clinic end generated code: output=70f35de5ac7ad630 input=87b9ec648b742936]*/ +{ +int lineno = PyFrame_GetLineNumber(self); +if (lineno < 0) { +Py_RETURN_NONE; +} +return PyLong_FromLong(lineno); +} +/*[clinic input] +@critical_section +@getter +frame.f_lasti as frame_lasti +Return the index of the last attempted instruction in the frame. +[clinic start generated code]*/ +static PyObject * +frame_lasti_get_impl(PyFrameObject *self) +/*[clinic end generated code: output=03275b4f0327d1a2 input=0225ed49cb1fbeeb]*/ +{ +int lasti = _PyInterpreterFrame_LASTI(self->f_frame); +if (lasti < 0) { +return PyLong_FromLong(-1); +} +return PyLong_FromLong(lasti * sizeof(_Py_CODEUNIT)); +} +/*[clinic input] +@critical_section +@getter +frame.f_globals as frame_globals +Return the global variables in the frame. +[clinic start generated code]*/ +static PyObject * +frame_globals_get_impl(PyFrameObject *self) +/*[clinic end generated code: output=7758788c32885528 input=7fff7241357d314d]*/ +{ +PyObject *globals = self->f_frame->f_globals; +if (globals == NULL) { +globals = Py_None; +} +return Py_NewRef(globals); +} +/*[clinic input] +@critical_section +@getter +frame.f_builtins as frame_builtins +Return the built-in variables in the frame. +[clinic start generated code]*/ +static PyObject * +frame_builtins_get_impl(PyFrameObject *self) +/*[clinic end generated code: output=45362faa6d42c702 input=27c696d6ffcad2c7]*/ +{ +PyObject *builtins = self->f_frame->f_builtins; +if (builtins == NULL) { +builtins = Py_None; +} +return Py_NewRef(builtins); +} +/*[clinic input] +@getter +frame.f_code as frame_code +Return the code object being executed in this frame. +[clinic start generated code]*/ +static PyObject * +frame_code_get_impl(PyFrameObject *self) +/*[clinic end generated code: output=a5ed6207395a8cef input=e127e7098c124816]*/ +{ +if (PySys_Audit("object.__getattr__", "Os", self, "f_code") < 0) { +return NULL; +} +return (PyObject *)PyFrame_GetCode(self); +} +/*[clinic input] +@critical_section +@getter +frame.f_back as frame_back +[clinic start generated code]*/ +static PyObject * +frame_back_get_impl(PyFrameObject *self) +/*[clinic end generated code: output=3a84c22a55a63c79 input=9e528570d0e1f44a]*/ +{ +PyObject *res = (PyObject *)PyFrame_GetBack(self); +if (res == NULL) { +Py_RETURN_NONE; +} +return res; +} +/*[clinic input] +@critical_section +@getter +frame.f_trace_opcodes as frame_trace_opcodes +Return True if opcode tracing is enabled, False otherwise. +[clinic start generated code]*/ +static PyObject * +frame_trace_opcodes_get_impl(PyFrameObject *self) +/*[clinic end generated code: output=53ff41d09cc32e87 input=4eb91dc88e04677a]*/ +{ +return self->f_trace_opcodes ? Py_True : Py_False; +} +/*[clinic input] +@critical_section +@setter +frame.f_trace_opcodes as frame_trace_opcodes +[clinic start generated code]*/ +static int +frame_trace_opcodes_set_impl(PyFrameObject *self, PyObject *value) +/*[clinic end generated code: output=92619da2bfccd449 input=7e286eea3c0333ff]*/ +{ +if (!PyBool_Check(value)) { +PyErr_SetString(PyExc_TypeError, +"attribute value type must be bool"); +return -1; +} +if (value == Py_True) { +self->f_trace_opcodes = 1; +if (self->f_trace) { +return _PyEval_SetOpcodeTrace(self, true); +} +} +else { +self->f_trace_opcodes = 0; +return _PyEval_SetOpcodeTrace(self, false); +} +return 0; +} +/* Model the evaluation stack, to determine which jumps +* are safe and how many values needs to be popped. +* The stack is modelled by a 64 integer, treating any +* stack that can't fit into 64 bits as "overflowed". +*/ +typedef enum kind { +Iterator = 1, +Except = 2, +Object = 3, +Null = 4, +Lasti = 5, +} Kind; +static int +compatible_kind(Kind from, Kind to) { +if (to == 0) { +return 0; +} +if (to == Object) { +return from != Null; +} +if (to == Null) { +return 1; +} +return from == to; +} +#define BITS_PER_BLOCK 3 +#define UNINITIALIZED -2 +#define OVERFLOWED -1 +#define MAX_STACK_ENTRIES (63/BITS_PER_BLOCK) +#define WILL_OVERFLOW (1ULL<<((MAX_STACK_ENTRIES-1)*BITS_PER_BLOCK)) +#define EMPTY_STACK 0 +static inline int64_t +push_value(int64_t stack, Kind kind) +{ +if (((uint64_t)stack) >= WILL_OVERFLOW) { +return OVERFLOWED; +} +else { +return (stack << BITS_PER_BLOCK) | kind; +} +} +static inline int64_t +pop_value(int64_t stack) +{ +return Py_ARITHMETIC_RIGHT_SHIFT(int64_t, stack, BITS_PER_BLOCK); +} +#define MASK ((1<= 1); +return (stack>>(BITS_PER_BLOCK*(n-1))) & MASK; +} +static Kind +stack_swap(int64_t stack, int n) +{ +assert(n >= 1); +Kind to_swap = peek(stack, n); +Kind top = top_of_stack(stack); +int shift = BITS_PER_BLOCK*(n-1); +int64_t replaced_low = (stack & ~(MASK << shift)) | (top << shift); +int64_t replaced_top = (replaced_low & ~MASK) | to_swap; +return replaced_top; +} +static int64_t +pop_to_level(int64_t stack, int level) { +if (level == 0) { +return EMPTY_STACK; +} +int64_t max_item = (1< level_max_stack) { +stack = pop_value(stack); +} +return stack; +} +#if 0 +/* These functions are useful for debugging the stack marking code */ +static char +tos_char(int64_t stack) { +switch(top_of_stack(stack)) { +case Iterator: +return 'I'; +case Except: +return 'E'; +case Object: +return 'O'; +case Lasti: +return 'L'; +case Null: +return 'N'; +} +return '?'; +} +static void +print_stack(int64_t stack) { +if (stack < 0) { +if (stack == UNINITIALIZED) { +printf("---"); +} +else if (stack == OVERFLOWED) { +printf("OVERFLOWED"); +} +else { +printf("??"); +} +return; +} +while (stack) { +printf("%c", tos_char(stack)); +stack = pop_value(stack); +} +} +static void +print_stacks(int64_t *stacks, int n) { +for (int i = 0; i < n; i++) { +printf("%d: ", i); +print_stack(stacks[i]); +printf("\n"); +} +} +#endif +static int64_t * +mark_stacks(PyCodeObject *code_obj, int len) +{ +PyObject *co_code = _PyCode_GetCode(code_obj); +if (co_code == NULL) { +return NULL; +} +int64_t *stacks = PyMem_New(int64_t, len+1); +if (stacks == NULL) { +PyErr_NoMemory(); +Py_DECREF(co_code); +return NULL; +} +for (int i = 1; i <= len; i++) { +stacks[i] = UNINITIALIZED; +} +stacks[0] = EMPTY_STACK; +int todo = 1; +while (todo) { +todo = 0; +/* Scan instructions */ +for (int i = 0; i < len;) { +int j; +int64_t next_stack = stacks[i]; +_Py_CODEUNIT inst = _Py_GetBaseCodeUnit(code_obj, i); +int opcode = inst.op.code; +int oparg = 0; +while (opcode == EXTENDED_ARG) { +oparg = (oparg << 8) | inst.op.arg; +i++; +inst = _Py_GetBaseCodeUnit(code_obj, i); +opcode = inst.op.code; +stacks[i] = next_stack; +} +oparg = (oparg << 8) | inst.op.arg; +int next_i = i + _PyOpcode_Caches[opcode] + 1; +if (next_stack == UNINITIALIZED) { +i = next_i; +continue; +} +switch (opcode) { +case POP_JUMP_IF_FALSE: +case POP_JUMP_IF_TRUE: +case POP_JUMP_IF_NONE: +case POP_JUMP_IF_NOT_NONE: +{ +int64_t target_stack; +j = next_i + oparg; +assert(j < len); +next_stack = pop_value(next_stack); +target_stack = next_stack; +assert(stacks[j] == UNINITIALIZED || stacks[j] == target_stack); +stacks[j] = target_stack; +stacks[next_i] = next_stack; +break; +} +case SEND: +j = oparg + i + INLINE_CACHE_ENTRIES_SEND + 1; +assert(j < len); +assert(stacks[j] == UNINITIALIZED || stacks[j] == next_stack); +stacks[j] = next_stack; +stacks[next_i] = next_stack; +break; +case JUMP_FORWARD: +j = oparg + i + 1; +assert(j < len); +assert(stacks[j] == UNINITIALIZED || stacks[j] == next_stack); +stacks[j] = next_stack; +break; +case JUMP_BACKWARD: +case JUMP_BACKWARD_NO_INTERRUPT: +j = next_i - oparg; +assert(j >= 0); +assert(j < len); +if (stacks[j] == UNINITIALIZED && j < i) { +todo = 1; +} +assert(stacks[j] == UNINITIALIZED || stacks[j] == next_stack); +stacks[j] = next_stack; +break; +case GET_ITER: +next_stack = push_value(pop_value(next_stack), Iterator); +next_stack = push_value(next_stack, Iterator); +stacks[next_i] = next_stack; +break; +case GET_AITER: +next_stack = push_value(pop_value(next_stack), Iterator); +stacks[next_i] = next_stack; +break; +case FOR_ITER: +{ +int64_t target_stack = push_value(next_stack, Object); +stacks[next_i] = target_stack; +j = oparg + 1 + INLINE_CACHE_ENTRIES_FOR_ITER + i; +assert(j < len); +assert(stacks[j] == UNINITIALIZED || stacks[j] == target_stack); +stacks[j] = target_stack; +break; +} +case END_ASYNC_FOR: +next_stack = pop_value(pop_value(next_stack)); +stacks[next_i] = next_stack; +break; +case PUSH_EXC_INFO: +next_stack = push_value(next_stack, Except); +stacks[next_i] = next_stack; +break; +case POP_EXCEPT: +assert(top_of_stack(next_stack) == Except); +next_stack = pop_value(next_stack); +stacks[next_i] = next_stack; +break; +case RETURN_VALUE: +assert(pop_value(next_stack) == EMPTY_STACK); +assert(top_of_stack(next_stack) == Object); +break; +case RAISE_VARARGS: +break; +case RERAISE: +assert(top_of_stack(next_stack) == Except); +/* End of block */ +break; +case PUSH_NULL: +next_stack = push_value(next_stack, Null); +stacks[next_i] = next_stack; +break; +case LOAD_GLOBAL: +{ +int j = oparg; +next_stack = push_value(next_stack, Object); +if (j & 1) { +next_stack = push_value(next_stack, Null); +} +stacks[next_i] = next_stack; +break; +} +case LOAD_ATTR: +{ +assert(top_of_stack(next_stack) == Object); +int j = oparg; +if (j & 1) { +next_stack = pop_value(next_stack); +next_stack = push_value(next_stack, Object); +next_stack = push_value(next_stack, Null); +} +stacks[next_i] = next_stack; +break; +} +case SWAP: +{ +int n = oparg; +next_stack = stack_swap(next_stack, n); +stacks[next_i] = next_stack; +break; +} +case COPY: +{ +int n = oparg; +next_stack = push_value(next_stack, peek(next_stack, n)); +stacks[next_i] = next_stack; +break; +} +case CACHE: +case RESERVED: +{ +assert(0); +} +default: +{ +int delta = PyCompile_OpcodeStackEffect(opcode, oparg); +assert(delta != PY_INVALID_STACK_EFFECT); +while (delta < 0) { +next_stack = pop_value(next_stack); +delta++; +} +while (delta > 0) { +next_stack = push_value(next_stack, Object); +delta--; +} +stacks[next_i] = next_stack; +} +} +i = next_i; +} +/* Scan exception table */ +unsigned char *start = (unsigned char *)PyBytes_AS_STRING(code_obj->co_exceptiontable); +unsigned char *end = start + PyBytes_GET_SIZE(code_obj->co_exceptiontable); +unsigned char *scan = start; +while (scan < end) { +int start_offset, size, handler; +scan = parse_varint(scan, &start_offset); +assert(start_offset >= 0 && start_offset < len); +scan = parse_varint(scan, &size); +assert(size >= 0 && start_offset+size <= len); +scan = parse_varint(scan, &handler); +assert(handler >= 0 && handler < len); +int depth_and_lasti; +scan = parse_varint(scan, &depth_and_lasti); +int level = depth_and_lasti >> 1; +int lasti = depth_and_lasti & 1; +if (stacks[start_offset] != UNINITIALIZED) { +if (stacks[handler] == UNINITIALIZED) { +todo = 1; +uint64_t target_stack = pop_to_level(stacks[start_offset], level); +if (lasti) { +target_stack = push_value(target_stack, Lasti); +} +target_stack = push_value(target_stack, Except); +stacks[handler] = target_stack; +} +} +} +} +Py_DECREF(co_code); +return stacks; +} +static int +compatible_stack(int64_t from_stack, int64_t to_stack) +{ +if (from_stack < 0 || to_stack < 0) { +return 0; +} +while(from_stack > to_stack) { +from_stack = pop_value(from_stack); +} +while(from_stack) { +Kind from_top = top_of_stack(from_stack); +Kind to_top = top_of_stack(to_stack); +if (!compatible_kind(from_top, to_top)) { +return 0; +} +from_stack = pop_value(from_stack); +to_stack = pop_value(to_stack); +} +return to_stack == 0; +} +static const char * +explain_incompatible_stack(int64_t to_stack) +{ +assert(to_stack != 0); +if (to_stack == OVERFLOWED) { +return "stack is too deep to analyze"; +} +if (to_stack == UNINITIALIZED) { +return "can't jump into an exception handler, or code may be unreachable"; +} +Kind target_kind = top_of_stack(to_stack); +switch(target_kind) { +case Except: +return "can't jump into an 'except' block as there's no exception"; +case Lasti: +return "can't jump into a re-raising block as there's no location"; +case Object: +case Null: +return "incompatible stacks"; +case Iterator: +return "can't jump into the body of a for loop"; +default: +Py_UNREACHABLE(); +} +} +static int * +marklines(PyCodeObject *code, int len) +{ +PyCodeAddressRange bounds; +_PyCode_InitAddressRange(code, &bounds); +assert (bounds.ar_end == 0); +int last_line = -1; +int *linestarts = PyMem_New(int, len); +if (linestarts == NULL) { +return NULL; +} +for (int i = 0; i < len; i++) { +linestarts[i] = -1; +} +while (_PyLineTable_NextAddressRange(&bounds)) { +assert(bounds.ar_start / (int)sizeof(_Py_CODEUNIT) < len); +if (bounds.ar_line != last_line && bounds.ar_line != -1) { +linestarts[bounds.ar_start / sizeof(_Py_CODEUNIT)] = bounds.ar_line; +last_line = bounds.ar_line; +} +} +return linestarts; +} +static int +first_line_not_before(int *lines, int len, int line) +{ +int result = INT_MAX; +for (int i = 0; i < len; i++) { +if (lines[i] < result && lines[i] >= line) { +result = lines[i]; +} +} +if (result == INT_MAX) { +return -1; +} +return result; +} +static bool frame_is_suspended(PyFrameObject *frame) +{ +assert(!_PyFrame_IsIncomplete(frame->f_frame)); +if (frame->f_frame->owner == FRAME_OWNED_BY_GENERATOR) { +PyGenObject *gen = _PyGen_GetGeneratorFromFrame(frame->f_frame); +return FRAME_STATE_SUSPENDED(gen->gi_frame_state); +} +return false; +} +/* Setter for f_lineno - you can set f_lineno from within a trace function in +* order to jump to a given line of code, subject to some restrictions. Most +* lines are OK to jump to because they don't make any assumptions about the +* state of the stack (obvious because you could remove the line and the code +* would still work without any stack errors), but there are some constructs +* that limit jumping: +* +* o Any exception handlers. +* o 'for' and 'async for' loops can't be jumped into because the +* iterator needs to be on the stack. +* o Jumps cannot be made from within a trace function invoked with a +* 'return' or 'exception' event since the eval loop has been exited at +* that time. +*/ +/*[clinic input] +@critical_section +@setter +frame.f_lineno as frame_lineno +[clinic start generated code]*/ +static int +frame_lineno_set_impl(PyFrameObject *self, PyObject *value) +/*[clinic end generated code: output=e64c86ff6be64292 input=36ed3c896b27fb91]*/ +{ +PyCodeObject *code = _PyFrame_GetCode(self->f_frame); +if (value == NULL) { +PyErr_SetString(PyExc_AttributeError, "cannot delete attribute"); +return -1; +} +/* f_lineno must be an integer. */ +if (!PyLong_CheckExact(value)) { +PyErr_SetString(PyExc_ValueError, +"lineno must be an integer"); +return -1; +} +bool is_suspended = frame_is_suspended(self); +/* +* This code preserves the historical restrictions on +* setting the line number of a frame. +* Jumps are forbidden on a 'return' trace event (except after a yield). +* Jumps from 'call' trace events are also forbidden. +* In addition, jumps are forbidden when not tracing, +* as this is a debugging feature. +*/ +int what_event = PyThreadState_GET()->what_event; +if (what_event < 0) { +PyErr_Format(PyExc_ValueError, +"f_lineno can only be set in a trace function"); +return -1; +} +switch (what_event) { +case PY_MONITORING_EVENT_PY_RESUME: +case PY_MONITORING_EVENT_JUMP: +case PY_MONITORING_EVENT_BRANCH: +case PY_MONITORING_EVENT_BRANCH_LEFT: +case PY_MONITORING_EVENT_BRANCH_RIGHT: +case PY_MONITORING_EVENT_LINE: +case PY_MONITORING_EVENT_PY_YIELD: +/* Setting f_lineno is allowed for the above events */ +break; +case PY_MONITORING_EVENT_PY_START: +PyErr_Format(PyExc_ValueError, +"can't jump from the 'call' trace event of a new frame"); +return -1; +case PY_MONITORING_EVENT_CALL: +case PY_MONITORING_EVENT_C_RETURN: +PyErr_SetString(PyExc_ValueError, +"can't jump during a call"); +return -1; +case PY_MONITORING_EVENT_PY_RETURN: +case PY_MONITORING_EVENT_PY_UNWIND: +case PY_MONITORING_EVENT_PY_THROW: +case PY_MONITORING_EVENT_RAISE: +case PY_MONITORING_EVENT_C_RAISE: +case PY_MONITORING_EVENT_INSTRUCTION: +case PY_MONITORING_EVENT_EXCEPTION_HANDLED: +PyErr_Format(PyExc_ValueError, +"can only jump from a 'line' trace event"); +return -1; +default: +PyErr_SetString(PyExc_SystemError, +"unexpected event type"); +return -1; +} +int new_lineno; +/* Fail if the line falls outside the code block and +select first line with actual code. */ +int overflow; +long l_new_lineno = PyLong_AsLongAndOverflow(value, &overflow); +if (overflow +#if SIZEOF_LONG > SIZEOF_INT +|| l_new_lineno > INT_MAX +|| l_new_lineno < INT_MIN +#endif +) { +PyErr_SetString(PyExc_ValueError, +"lineno out of range"); +return -1; +} +new_lineno = (int)l_new_lineno; +if (new_lineno < code->co_firstlineno) { +PyErr_Format(PyExc_ValueError, +"line %d comes before the current code block", +new_lineno); +return -1; +} +/* PyCode_NewWithPosOnlyArgs limits co_code to be under INT_MAX so this +* should never overflow. */ +int len = (int)Py_SIZE(code); +int *lines = marklines(code, len); +if (lines == NULL) { +return -1; +} +new_lineno = first_line_not_before(lines, len, new_lineno); +if (new_lineno < 0) { +PyErr_Format(PyExc_ValueError, +"line %d comes after the current code block", +(int)l_new_lineno); +PyMem_Free(lines); +return -1; +} +int64_t *stacks = mark_stacks(code, len); +if (stacks == NULL) { +PyMem_Free(lines); +return -1; +} +int64_t best_stack = OVERFLOWED; +int best_addr = -1; +int64_t start_stack = stacks[_PyInterpreterFrame_LASTI(self->f_frame)]; +int err = -1; +const char *msg = "cannot find bytecode for specified line"; +for (int i = 0; i < len; i++) { +if (lines[i] == new_lineno) { +int64_t target_stack = stacks[i]; +if (compatible_stack(start_stack, target_stack)) { +err = 0; +if (target_stack > best_stack) { +best_stack = target_stack; +best_addr = i; +} +} +else if (err < 0) { +if (start_stack == OVERFLOWED) { +msg = "stack to deep to analyze"; +} +else if (start_stack == UNINITIALIZED) { +msg = "can't jump from unreachable code"; +} +else { +msg = explain_incompatible_stack(target_stack); +err = 1; +} +} +} +} +PyMem_Free(stacks); +PyMem_Free(lines); +if (err) { +PyErr_SetString(PyExc_ValueError, msg); +return -1; +} +// Populate any NULL locals that the compiler might have "proven" to exist +// in the new location. Rather than crashing or changing co_code, just bind +// None instead: +int unbound = 0; +for (int i = 0; i < code->co_nlocalsplus; i++) { +// Counting every unbound local is overly-cautious, but a full flow +// analysis (like we do in the compiler) is probably too expensive: +unbound += PyStackRef_IsNull(self->f_frame->localsplus[i]); +} +if (unbound) { +const char *e = "assigning None to %d unbound local%s"; +const char *s = (unbound == 1) ? "" : "s"; +if (PyErr_WarnFormat(PyExc_RuntimeWarning, 0, e, unbound, s)) { +return -1; +} +// Do this in a second pass to avoid writing a bunch of Nones when +// warnings are being treated as errors and the previous bit raises: +for (int i = 0; i < code->co_nlocalsplus; i++) { +if (PyStackRef_IsNull(self->f_frame->localsplus[i])) { +self->f_frame->localsplus[i] = PyStackRef_None; +unbound--; +} +} +assert(unbound == 0); +} +if (is_suspended) { +/* Account for value popped by yield */ +start_stack = pop_value(start_stack); +} +while (start_stack > best_stack) { +_PyStackRef popped = _PyFrame_StackPop(self->f_frame); +if (top_of_stack(start_stack) == Except) { +/* Pop exception stack as well as the evaluation stack */ +PyObject *exc = PyStackRef_AsPyObjectBorrow(popped); +assert(PyExceptionInstance_Check(exc) || exc == Py_None); +PyThreadState *tstate = _PyThreadState_GET(); +Py_XSETREF(tstate->exc_info->exc_value, exc == Py_None ? NULL : exc); +} +else { +PyStackRef_XCLOSE(popped); +} +start_stack = pop_value(start_stack); +} +/* Finally set the new lasti and return OK. */ +self->f_lineno = 0; +self->f_frame->instr_ptr = _PyFrame_GetBytecode(self->f_frame) + best_addr; +return 0; +} +/*[clinic input] +@permit_long_summary +@critical_section +@getter +frame.f_trace as frame_trace +Return the trace function for this frame, or None if no trace function is set. +[clinic start generated code]*/ +static PyObject * +frame_trace_get_impl(PyFrameObject *self) +/*[clinic end generated code: output=5475cbfce07826cd input=e4eacf2c68cac577]*/ +{ +PyObject* trace = self->f_trace; +if (trace == NULL) { +trace = Py_None; +} +return Py_NewRef(trace); +} +/*[clinic input] +@permit_long_summary +@critical_section +@setter +frame.f_trace as frame_trace +[clinic start generated code]*/ +static int +frame_trace_set_impl(PyFrameObject *self, PyObject *value) +/*[clinic end generated code: output=d6fe08335cf76ae4 input=e57380734815dac5]*/ +{ +if (value == Py_None) { +value = NULL; +} +if (value != self->f_trace) { +Py_XSETREF(self->f_trace, Py_XNewRef(value)); +if (value != NULL && self->f_trace_opcodes) { +return _PyEval_SetOpcodeTrace(self, true); +} +} +return 0; +} +/*[clinic input] +@critical_section +@getter +frame.f_generator as frame_generator +Return the generator or coroutine associated with this frame, or None. +[clinic start generated code]*/ +static PyObject * +frame_generator_get_impl(PyFrameObject *self) +/*[clinic end generated code: output=97aeb2392562e55b input=00a2bd008b239ab0]*/ +{ +if (self->f_frame->owner == FRAME_OWNED_BY_GENERATOR) { +PyObject *gen = (PyObject *)_PyGen_GetGeneratorFromFrame(self->f_frame); +return Py_NewRef(gen); +} +Py_RETURN_NONE; +} +static PyGetSetDef frame_getsetlist[] = { +FRAME_BACK_GETSETDEF +FRAME_LOCALS_GETSETDEF +FRAME_LINENO_GETSETDEF +FRAME_TRACE_GETSETDEF +FRAME_LASTI_GETSETDEF +FRAME_GLOBALS_GETSETDEF +FRAME_BUILTINS_GETSETDEF +FRAME_CODE_GETSETDEF +FRAME_TRACE_OPCODES_GETSETDEF +FRAME_GENERATOR_GETSETDEF +{0} +}; +static void +frame_dealloc(PyObject *op) +{ +/* It is the responsibility of the owning generator/coroutine +* to have cleared the generator pointer */ +PyFrameObject *f = PyFrameObject_CAST(op); +if (_PyObject_GC_IS_TRACKED(f)) { +_PyObject_GC_UNTRACK(f); +} +/* GH-106092: If f->f_frame was on the stack and we reached the maximum +* nesting depth for deallocations, the trashcan may have delayed this +* deallocation until after f->f_frame is freed. Avoid dereferencing +* f->f_frame unless we know it still points to valid memory. */ +_PyInterpreterFrame *frame = (_PyInterpreterFrame *)f->_f_frame_data; +/* Kill all local variables including specials, if we own them */ +if (f->f_frame == frame && frame->owner == FRAME_OWNED_BY_FRAME_OBJECT) { +PyStackRef_CLEAR(frame->f_executable); +PyStackRef_CLEAR(frame->f_funcobj); +Py_CLEAR(frame->f_locals); +_PyStackRef *locals = _PyFrame_GetLocalsArray(frame); +_PyStackRef *sp = frame->stackpointer; +while (sp > locals) { +sp--; +PyStackRef_CLEAR(*sp); +} +} +Py_CLEAR(f->f_back); +Py_CLEAR(f->f_trace); +Py_CLEAR(f->f_extra_locals); +Py_CLEAR(f->f_locals_cache); +Py_CLEAR(f->f_overwritten_fast_locals); +PyObject_GC_Del(f); +} +static int +frame_traverse(PyObject *op, visitproc visit, void *arg) +{ +PyFrameObject *f = PyFrameObject_CAST(op); +Py_VISIT(f->f_back); +Py_VISIT(f->f_trace); +Py_VISIT(f->f_extra_locals); +Py_VISIT(f->f_locals_cache); +Py_VISIT(f->f_overwritten_fast_locals); +if (f->f_frame->owner != FRAME_OWNED_BY_FRAME_OBJECT) { +return 0; +} +assert(f->f_frame->frame_obj == NULL); +return _PyFrame_Traverse(f->f_frame, visit, arg); +} +static int +frame_tp_clear(PyObject *op) +{ +PyFrameObject *f = PyFrameObject_CAST(op); +Py_CLEAR(f->f_trace); +Py_CLEAR(f->f_extra_locals); +Py_CLEAR(f->f_locals_cache); +Py_CLEAR(f->f_overwritten_fast_locals); +/* locals and stack */ +_PyStackRef *locals = _PyFrame_GetLocalsArray(f->f_frame); +_PyStackRef *sp = f->f_frame->stackpointer; +assert(sp >= locals); +while (sp > locals) { +sp--; +PyStackRef_CLEAR(*sp); +} +f->f_frame->stackpointer = locals; +Py_CLEAR(f->f_frame->f_locals); +return 0; +} +/*[clinic input] +@critical_section +frame.clear +Clear all references held by the frame. +[clinic start generated code]*/ +static PyObject * +frame_clear_impl(PyFrameObject *self) +/*[clinic end generated code: output=864c662f16e9bfcc input=c358f9cff5f9b681]*/ +{ +if (self->f_frame->owner == FRAME_OWNED_BY_GENERATOR) { +PyGenObject *gen = _PyGen_GetGeneratorFromFrame(self->f_frame); +if (_PyGen_ClearFrame(gen) < 0) { +return NULL; +} +} +else if (self->f_frame->owner == FRAME_OWNED_BY_THREAD) { +PyErr_SetString(PyExc_RuntimeError, +"cannot clear an executing frame"); +return NULL; +} +else { +assert(self->f_frame->owner == FRAME_OWNED_BY_FRAME_OBJECT); +(void)frame_tp_clear((PyObject *)self); +} +Py_RETURN_NONE; +} +/*[clinic input] +@critical_section +frame.__sizeof__ +Return the size of the frame in memory, in bytes. +[clinic start generated code]*/ +static PyObject * +frame___sizeof___impl(PyFrameObject *self) +/*[clinic end generated code: output=82948688e81078e2 input=908f90a83e73131d]*/ +{ +Py_ssize_t res; +res = offsetof(PyFrameObject, _f_frame_data) + offsetof(_PyInterpreterFrame, localsplus); +PyCodeObject *code = _PyFrame_GetCode(self->f_frame); +res += _PyFrame_NumSlotsForCodeObject(code) * sizeof(PyObject *); +return PyLong_FromSsize_t(res); +} +static PyObject * +frame_repr(PyObject *op) +{ +PyFrameObject *f = PyFrameObject_CAST(op); +int lineno = PyFrame_GetLineNumber(f); +PyCodeObject *code = _PyFrame_GetCode(f->f_frame); +return PyUnicode_FromFormat( +"", +f, code->co_filename, lineno, code->co_name); +} +static PyMethodDef frame_methods[] = { +FRAME_CLEAR_METHODDEF +FRAME___SIZEOF___METHODDEF +{NULL, NULL} /* sentinel */ +}; +PyTypeObject PyFrame_Type = { +PyVarObject_HEAD_INIT(&PyType_Type, 0) +"frame", +offsetof(PyFrameObject, _f_frame_data) + +offsetof(_PyInterpreterFrame, localsplus), +sizeof(PyObject *), +frame_dealloc, /* tp_dealloc */ +0, /* tp_vectorcall_offset */ +0, /* tp_getattr */ +0, /* tp_setattr */ +0, /* tp_as_async */ +frame_repr, /* tp_repr */ +0, /* tp_as_number */ +0, /* tp_as_sequence */ +0, /* tp_as_mapping */ +0, /* tp_hash */ +0, /* tp_call */ +0, /* tp_str */ +PyObject_GenericGetAttr, /* tp_getattro */ +PyObject_GenericSetAttr, /* tp_setattro */ +0, /* tp_as_buffer */ +Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */ +0, /* tp_doc */ +frame_traverse, /* tp_traverse */ +frame_tp_clear, /* tp_clear */ +0, /* tp_richcompare */ +0, /* tp_weaklistoffset */ +0, /* tp_iter */ +0, /* tp_iternext */ +frame_methods, /* tp_methods */ +frame_memberlist, /* tp_members */ +frame_getsetlist, /* tp_getset */ +0, /* tp_base */ +0, /* tp_dict */ +}; +static void +init_frame(PyThreadState *tstate, _PyInterpreterFrame *frame, +PyFunctionObject *func, PyObject *locals) +{ +PyCodeObject *code = (PyCodeObject *)func->func_code; +_PyFrame_Initialize(tstate, frame, PyStackRef_FromPyObjectNew(func), +Py_XNewRef(locals), code, 0, NULL); +} +PyFrameObject* +_PyFrame_New_NoTrack(PyCodeObject *code) +{ +CALL_STAT_INC(frame_objects_created); +int slots = code->co_nlocalsplus + code->co_stacksize; +PyFrameObject *f = PyObject_GC_NewVar(PyFrameObject, &PyFrame_Type, slots); +if (f == NULL) { +return NULL; +} +f->f_back = NULL; +f->f_trace = NULL; +f->f_trace_lines = 1; +f->f_trace_opcodes = 0; +f->f_lineno = 0; +f->f_extra_locals = NULL; +f->f_locals_cache = NULL; +f->f_overwritten_fast_locals = NULL; +return f; +} +/* Legacy API */ +PyFrameObject* +PyFrame_New(PyThreadState *tstate, PyCodeObject *code, +PyObject *globals, PyObject *locals) +{ +PyObject *builtins = _PyDict_LoadBuiltinsFromGlobals(globals); +if (builtins == NULL) { +return NULL; +} +PyFrameConstructor desc = { +.fc_globals = globals, +.fc_builtins = builtins, +.fc_name = code->co_name, +.fc_qualname = code->co_name, +.fc_code = (PyObject *)code, +.fc_defaults = NULL, +.fc_kwdefaults = NULL, +.fc_closure = NULL +}; +PyFunctionObject *func = _PyFunction_FromConstructor(&desc); +_Py_DECREF_BUILTINS(builtins); +if (func == NULL) { +return NULL; +} +PyFrameObject *f = _PyFrame_New_NoTrack(code); +if (f == NULL) { +Py_DECREF(func); +return NULL; +} +init_frame(tstate, (_PyInterpreterFrame *)f->_f_frame_data, func, locals); +f->f_frame = (_PyInterpreterFrame *)f->_f_frame_data; +f->f_frame->owner = FRAME_OWNED_BY_FRAME_OBJECT; +// This frame needs to be "complete", so pretend that the first RESUME ran: +f->f_frame->instr_ptr = _PyCode_CODE(code) + code->_co_firsttraceable + 1; +assert(!_PyFrame_IsIncomplete(f->f_frame)); +Py_DECREF(func); +_PyObject_GC_TRACK(f); +return f; +} +// Initialize frame free variables if needed +static void +frame_init_get_vars(_PyInterpreterFrame *frame) +{ +// COPY_FREE_VARS has no quickened forms, so no need to use _PyOpcode_Deopt +// here: +PyCodeObject *co = _PyFrame_GetCode(frame); +int lasti = _PyInterpreterFrame_LASTI(frame); +if (!(lasti < 0 +&& _PyFrame_GetBytecode(frame)->op.code == COPY_FREE_VARS +&& PyStackRef_FunctionCheck(frame->f_funcobj))) +{ +/* Free vars are initialized */ +return; +} +/* Free vars have not been initialized -- Do that */ +PyFunctionObject *func = _PyFrame_GetFunction(frame); +PyObject *closure = func->func_closure; +int offset = PyUnstable_Code_GetFirstFree(co); +for (int i = 0; i < co->co_nfreevars; ++i) { +PyObject *o = PyTuple_GET_ITEM(closure, i); +frame->localsplus[offset + i] = PyStackRef_FromPyObjectNew(o); +} +// COPY_FREE_VARS doesn't have inline CACHEs, either: +frame->instr_ptr = _PyFrame_GetBytecode(frame); +} +static int +frame_get_var(_PyInterpreterFrame *frame, PyCodeObject *co, int i, +PyObject **pvalue) +{ +_PyLocals_Kind kind = _PyLocals_GetKind(co->co_localspluskinds, i); +/* If the namespace is unoptimized, then one of the +following cases applies: +1. It does not contain free variables, because it +uses import * or is a top-level namespace. +2. It is a class namespace. +We don't want to accidentally copy free variables +into the locals dict used by the class. +*/ +if (kind & CO_FAST_FREE && !(co->co_flags & CO_OPTIMIZED)) { +return 0; +} +PyObject *value = NULL; +if (frame->stackpointer == NULL || frame->stackpointer > frame->localsplus + i) { +value = PyStackRef_AsPyObjectBorrow(frame->localsplus[i]); +if (kind & CO_FAST_FREE) { +// The cell was set by COPY_FREE_VARS. +assert(value != NULL && PyCell_Check(value)); +value = PyCell_GetRef((PyCellObject *)value); +} +else if (kind & CO_FAST_CELL) { +if (value != NULL) { +if (PyCell_Check(value)) { +assert(!_PyFrame_IsIncomplete(frame)); +value = PyCell_GetRef((PyCellObject *)value); +} +else { +// (likely) Otherwise it is an arg (kind & CO_FAST_LOCAL), +// with the initial value set when the frame was created... +// (unlikely) ...or it was set via the f_locals proxy. +Py_INCREF(value); +} +} +} +else { +Py_XINCREF(value); +} +} +*pvalue = value; +return 1; +} +bool +_PyFrame_HasHiddenLocals(_PyInterpreterFrame *frame) +{ +/* +* This function returns if there are hidden locals introduced by PEP 709, +* which are the isolated fast locals for inline comprehensions +*/ +PyCodeObject* co = _PyFrame_GetCode(frame); +for (int i = 0; i < co->co_nlocalsplus; i++) { +_PyLocals_Kind kind = _PyLocals_GetKind(co->co_localspluskinds, i); +if (kind & CO_FAST_HIDDEN) { +if (framelocalsproxy_hasval(frame, co, i)) { +return true; +} +} +} +return false; +} +PyObject * +_PyFrame_GetLocals(_PyInterpreterFrame *frame) +{ +// We should try to avoid creating the FrameObject if possible. +// So we check if the frame is a module or class level scope +PyCodeObject *co = _PyFrame_GetCode(frame); +if (!(co->co_flags & CO_OPTIMIZED) && !_PyFrame_HasHiddenLocals(frame)) { +if (frame->f_locals == NULL) { +// We found cases when f_locals is NULL for non-optimized code. +// We fill the f_locals with an empty dict to avoid crash until +// we find the root cause. +frame->f_locals = PyDict_New(); +if (frame->f_locals == NULL) { +return NULL; +} +} +return Py_NewRef(frame->f_locals); +} +PyFrameObject* f = _PyFrame_GetFrameObject(frame); +return _PyFrameLocalsProxy_New(f); +} +PyObject * +PyFrame_GetVar(PyFrameObject *frame_obj, PyObject *name) +{ +if (!PyUnicode_Check(name)) { +PyErr_Format(PyExc_TypeError, "name must be str, not %s", +Py_TYPE(name)->tp_name); +return NULL; +} +_PyInterpreterFrame *frame = frame_obj->f_frame; +frame_init_get_vars(frame); +PyCodeObject *co = _PyFrame_GetCode(frame); +for (int i = 0; i < co->co_nlocalsplus; i++) { +PyObject *var_name = PyTuple_GET_ITEM(co->co_localsplusnames, i); +if (!_PyUnicode_Equal(var_name, name)) { +continue; +} +PyObject *value; +if (!frame_get_var(frame, co, i, &value)) { +break; +} +if (value == NULL) { +break; +} +return value; +} +PyErr_Format(PyExc_NameError, "variable %R does not exist", name); +return NULL; +} +PyObject * +PyFrame_GetVarString(PyFrameObject *frame, const char *name) +{ +PyObject *name_obj = PyUnicode_FromString(name); +if (name_obj == NULL) { +return NULL; +} +PyObject *value = PyFrame_GetVar(frame, name_obj); +Py_DECREF(name_obj); +return value; +} +int +PyFrame_FastToLocalsWithError(PyFrameObject *f) +{ +// Nothing to do here, as f_locals is now a write-through proxy in +// optimized frames. Soft-deprecated, since there's no maintenance hassle. +return 0; +} +void +PyFrame_FastToLocals(PyFrameObject *f) +{ +// Nothing to do here, as f_locals is now a write-through proxy in +// optimized frames. Soft-deprecated, since there's no maintenance hassle. +return; +} +void +PyFrame_LocalsToFast(PyFrameObject *f, int clear) +{ +// Nothing to do here, as f_locals is now a write-through proxy in +// optimized frames. Soft-deprecated, since there's no maintenance hassle. +return; +} +int +_PyFrame_IsEntryFrame(PyFrameObject *frame) +{ +assert(frame != NULL); +_PyInterpreterFrame *f = frame->f_frame; +assert(!_PyFrame_IsIncomplete(f)); +return f->previous && f->previous->owner == FRAME_OWNED_BY_INTERPRETER; +} +PyCodeObject * +PyFrame_GetCode(PyFrameObject *frame) +{ +assert(frame != NULL); +PyObject *code; +Py_BEGIN_CRITICAL_SECTION(frame); +assert(!_PyFrame_IsIncomplete(frame->f_frame)); +code = Py_NewRef(_PyFrame_GetCode(frame->f_frame)); +Py_END_CRITICAL_SECTION(); +return (PyCodeObject *)code; +} +PyFrameObject* +PyFrame_GetBack(PyFrameObject *frame) +{ +assert(frame != NULL); +assert(!_PyFrame_IsIncomplete(frame->f_frame)); +PyFrameObject *back = frame->f_back; +if (back == NULL) { +_PyInterpreterFrame *prev = frame->f_frame->previous; +prev = _PyFrame_GetFirstComplete(prev); +if (prev) { +back = _PyFrame_GetFrameObject(prev); +} +} +return (PyFrameObject*)Py_XNewRef(back); +} +PyObject* +PyFrame_GetLocals(PyFrameObject *frame) +{ +assert(!_PyFrame_IsIncomplete(frame->f_frame)); +return frame_locals_get((PyObject *)frame, NULL); +} +PyObject* +PyFrame_GetGlobals(PyFrameObject *frame) +{ +assert(!_PyFrame_IsIncomplete(frame->f_frame)); +return frame_globals_get((PyObject *)frame, NULL); +} +PyObject* +PyFrame_GetBuiltins(PyFrameObject *frame) +{ +assert(!_PyFrame_IsIncomplete(frame->f_frame)); +return frame_builtins_get((PyObject *)frame, NULL); +} +int +PyFrame_GetLasti(PyFrameObject *frame) +{ +int ret; +Py_BEGIN_CRITICAL_SECTION(frame); +assert(!_PyFrame_IsIncomplete(frame->f_frame)); +int lasti = _PyInterpreterFrame_LASTI(frame->f_frame); +ret = lasti < 0 ? -1 : lasti * (int)sizeof(_Py_CODEUNIT); +Py_END_CRITICAL_SECTION(); +return ret; +} +PyObject * +PyFrame_GetGenerator(PyFrameObject *frame) +{ +assert(!_PyFrame_IsIncomplete(frame->f_frame)); +return frame_generator_get((PyObject *)frame, NULL); +} + +/* PickleBuffer object implementation */ +#include "Python.h" +#include "pycore_weakref.h" // FT_CLEAR_WEAKREFS() +#include +typedef struct { +PyObject_HEAD +/* The view exported by the original object */ +Py_buffer view; +PyObject *weakreflist; +} PyPickleBufferObject; +/* C API */ +PyObject * +PyPickleBuffer_FromObject(PyObject *base) +{ +PyTypeObject *type = &PyPickleBuffer_Type; +PyPickleBufferObject *self; +self = (PyPickleBufferObject *) type->tp_alloc(type, 0); +if (self == NULL) { +return NULL; +} +self->view.obj = NULL; +self->weakreflist = NULL; +if (PyObject_GetBuffer(base, &self->view, PyBUF_FULL_RO) < 0) { +Py_DECREF(self); +return NULL; +} +return (PyObject *) self; +} +const Py_buffer * +PyPickleBuffer_GetBuffer(PyObject *obj) +{ +PyPickleBufferObject *self = (PyPickleBufferObject *) obj; +if (!PyPickleBuffer_Check(obj)) { +PyErr_Format(PyExc_TypeError, +"expected PickleBuffer, %.200s found", +Py_TYPE(obj)->tp_name); +return NULL; +} +if (self->view.obj == NULL) { +PyErr_SetString(PyExc_ValueError, +"operation forbidden on released PickleBuffer object"); +return NULL; +} +return &self->view; +} +int +PyPickleBuffer_Release(PyObject *obj) +{ +PyPickleBufferObject *self = (PyPickleBufferObject *) obj; +if (!PyPickleBuffer_Check(obj)) { +PyErr_Format(PyExc_TypeError, +"expected PickleBuffer, %.200s found", +Py_TYPE(obj)->tp_name); +return -1; +} +PyBuffer_Release(&self->view); +return 0; +} +static PyObject * +picklebuf_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ +PyPickleBufferObject *self; +PyObject *base; +char *keywords[] = {"", NULL}; +if (!PyArg_ParseTupleAndKeywords(args, kwds, "O:PickleBuffer", +keywords, &base)) { +return NULL; +} +self = (PyPickleBufferObject *) type->tp_alloc(type, 0); +if (self == NULL) { +return NULL; +} +self->view.obj = NULL; +self->weakreflist = NULL; +if (PyObject_GetBuffer(base, &self->view, PyBUF_FULL_RO) < 0) { +Py_DECREF(self); +return NULL; +} +return (PyObject *) self; +} +static int +picklebuf_traverse(PyObject *op, visitproc visit, void *arg) +{ +PyPickleBufferObject *self = (PyPickleBufferObject*)op; +Py_VISIT(self->view.obj); +return 0; +} +static int +picklebuf_clear(PyObject *op) +{ +PyPickleBufferObject *self = (PyPickleBufferObject*)op; +PyBuffer_Release(&self->view); +return 0; +} +static void +picklebuf_dealloc(PyObject *op) +{ +PyPickleBufferObject *self = (PyPickleBufferObject*)op; +PyObject_GC_UnTrack(self); +FT_CLEAR_WEAKREFS(op, self->weakreflist); +PyBuffer_Release(&self->view); +Py_TYPE(self)->tp_free((PyObject *) self); +} +/* Buffer API */ +static int +picklebuf_getbuf(PyObject *op, Py_buffer *view, int flags) +{ +PyPickleBufferObject *self = (PyPickleBufferObject*)op; +if (self->view.obj == NULL) { +PyErr_SetString(PyExc_ValueError, +"operation forbidden on released PickleBuffer object"); +return -1; +} +return PyObject_GetBuffer(self->view.obj, view, flags); +} +static void +picklebuf_releasebuf(PyObject *self, Py_buffer *view) +{ +/* Since our bf_getbuffer redirects to the original object, this +* implementation is never called. It only exists to signal that +* buffers exported by PickleBuffer have non-trivial releasing +* behaviour (see check in Python/getargs.c). +*/ +} +static PyBufferProcs picklebuf_as_buffer = { +.bf_getbuffer = picklebuf_getbuf, +.bf_releasebuffer = picklebuf_releasebuf, +}; +/* Methods */ +static PyObject * +picklebuf_raw(PyObject *op, PyObject *Py_UNUSED(ignored)) +{ +PyPickleBufferObject *self = (PyPickleBufferObject*)op; +if (self->view.obj == NULL) { +PyErr_SetString(PyExc_ValueError, +"operation forbidden on released PickleBuffer object"); +return NULL; +} +if (self->view.suboffsets != NULL +|| !PyBuffer_IsContiguous(&self->view, 'A')) { +PyErr_SetString(PyExc_BufferError, +"cannot extract raw buffer from non-contiguous buffer"); +return NULL; +} +PyObject *m = PyMemoryView_FromObject((PyObject *) self); +if (m == NULL) { +return NULL; +} +PyMemoryViewObject *mv = (PyMemoryViewObject *) m; +assert(mv->view.suboffsets == NULL); +/* Mutate memoryview instance to make it a "raw" memoryview */ +mv->view.format = "B"; +mv->view.ndim = 1; +mv->view.itemsize = 1; +/* shape = (length,) */ +mv->view.shape = &mv->view.len; +/* strides = (1,) */ +mv->view.strides = &mv->view.itemsize; +/* Fix memoryview state flags */ +/* XXX Expose memoryobject.c's init_flags() instead? */ +mv->flags = _Py_MEMORYVIEW_C | _Py_MEMORYVIEW_FORTRAN; +return m; +} +PyDoc_STRVAR(picklebuf_raw_doc, +"raw($self, /)\n--\n\ +\n\ +Return a memoryview of the raw memory underlying this buffer.\n\ +Will raise BufferError is the buffer isn't contiguous."); +static PyObject * +picklebuf_release(PyObject *op, PyObject *Py_UNUSED(ignored)) +{ +PyPickleBufferObject *self = (PyPickleBufferObject*)op; +PyBuffer_Release(&self->view); +Py_RETURN_NONE; +} +PyDoc_STRVAR(picklebuf_release_doc, +"release($self, /)\n--\n\ +\n\ +Release the underlying buffer exposed by the PickleBuffer object."); +static PyMethodDef picklebuf_methods[] = { +{"raw", picklebuf_raw, METH_NOARGS, picklebuf_raw_doc}, +{"release", picklebuf_release, METH_NOARGS, picklebuf_release_doc}, +{NULL, NULL} +}; +PyTypeObject PyPickleBuffer_Type = { +PyVarObject_HEAD_INIT(NULL, 0) +.tp_name = "pickle.PickleBuffer", +.tp_doc = PyDoc_STR("Wrapper for potentially out-of-band buffers"), +.tp_basicsize = sizeof(PyPickleBufferObject), +.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, +.tp_new = picklebuf_new, +.tp_dealloc = picklebuf_dealloc, +.tp_traverse = picklebuf_traverse, +.tp_clear = picklebuf_clear, +.tp_weaklistoffset = offsetof(PyPickleBufferObject, weakreflist), +.tp_as_buffer = &picklebuf_as_buffer, +.tp_methods = picklebuf_methods, +}; + +/* +* Memoryview object implementation +* -------------------------------- +* +* This implementation is a complete rewrite contributed by Stefan Krah in +* Python 3.3. Substantial credit goes to Antoine Pitrou (who had already +* fortified and rewritten the previous implementation) and Nick Coghlan +* (who came up with the idea of the ManagedBuffer) for analyzing the complex +* ownership rules. +* +*/ +#include "Python.h" +#include "pycore_abstract.h" // _PyIndex_Check() +#include "pycore_memoryobject.h" // _PyManagedBuffer_Type +#include "pycore_object.h" // _PyObject_GC_UNTRACK() +#include "pycore_strhex.h" // _Py_strhex_with_sep() +#include // offsetof() +/*[clinic input] +class memoryview "PyMemoryViewObject *" "&PyMemoryView_Type" +[clinic start generated code]*/ +/*[clinic end generated code: output=da39a3ee5e6b4b0d input=e2e49d2192835219]*/ +#include "clinic/memoryobject.c.h" +/****************************************************************************/ +/* ManagedBuffer Object */ +/****************************************************************************/ +/* +ManagedBuffer Object: +--------------------- +The purpose of this object is to facilitate the handling of chained +memoryviews that have the same underlying exporting object. PEP-3118 +allows the underlying object to change while a view is exported. This +could lead to unexpected results when constructing a new memoryview +from an existing memoryview. +Rather than repeatedly redirecting buffer requests to the original base +object, all chained memoryviews use a single buffer snapshot. This +snapshot is generated by the constructor _PyManagedBuffer_FromObject(). +Ownership rules: +---------------- +The master buffer inside a managed buffer is filled in by the original +base object. shape, strides, suboffsets and format are read-only for +all consumers. +A memoryview's buffer is a private copy of the exporter's buffer. shape, +strides and suboffsets belong to the memoryview and are thus writable. +If a memoryview itself exports several buffers via memory_getbuf(), all +buffer copies share shape, strides and suboffsets. In this case, the +arrays are NOT writable. +Reference count assumptions: +---------------------------- +The 'obj' member of a Py_buffer must either be NULL or refer to the +exporting base object. In the Python codebase, all getbufferprocs +return a new reference to view.obj (example: bytes_buffer_getbuffer()). +PyBuffer_Release() decrements view.obj (if non-NULL), so the +releasebufferprocs must NOT decrement view.obj. +*/ +static inline _PyManagedBufferObject * +mbuf_alloc(void) +{ +_PyManagedBufferObject *mbuf; +mbuf = (_PyManagedBufferObject *) +PyObject_GC_New(_PyManagedBufferObject, &_PyManagedBuffer_Type); +if (mbuf == NULL) +return NULL; +mbuf->flags = 0; +mbuf->exports = 0; +mbuf->master.obj = NULL; +_PyObject_GC_TRACK(mbuf); +return mbuf; +} +static PyObject * +_PyManagedBuffer_FromObject(PyObject *base, int flags) +{ +_PyManagedBufferObject *mbuf; +mbuf = mbuf_alloc(); +if (mbuf == NULL) +return NULL; +if (PyObject_GetBuffer(base, &mbuf->master, flags) < 0) { +mbuf->master.obj = NULL; +Py_DECREF(mbuf); +return NULL; +} +return (PyObject *)mbuf; +} +static void +mbuf_release(_PyManagedBufferObject *self) +{ +if (self->flags&_Py_MANAGED_BUFFER_RELEASED) +return; +self->flags |= _Py_MANAGED_BUFFER_RELEASED; +/* PyBuffer_Release() decrements master->obj and sets it to NULL. */ +_PyObject_GC_UNTRACK(self); +PyBuffer_Release(&self->master); +} +static void +mbuf_dealloc(PyObject *_self) +{ +_PyManagedBufferObject *self = (_PyManagedBufferObject *)_self; +assert(self->exports == 0); +mbuf_release(self); +if (self->flags&_Py_MANAGED_BUFFER_FREE_FORMAT) +PyMem_Free(self->master.format); +PyObject_GC_Del(self); +} +static int +mbuf_traverse(PyObject *_self, visitproc visit, void *arg) +{ +_PyManagedBufferObject *self = (_PyManagedBufferObject *)_self; +Py_VISIT(self->master.obj); +return 0; +} +static int +mbuf_clear(PyObject *_self) +{ +_PyManagedBufferObject *self = (_PyManagedBufferObject *)_self; +assert(self->exports >= 0); +mbuf_release(self); +return 0; +} +PyTypeObject _PyManagedBuffer_Type = { +PyVarObject_HEAD_INIT(&PyType_Type, 0) +"managedbuffer", +sizeof(_PyManagedBufferObject), +0, +mbuf_dealloc, /* tp_dealloc */ +0, /* tp_vectorcall_offset */ +0, /* tp_getattr */ +0, /* tp_setattr */ +0, /* tp_as_async */ +0, /* tp_repr */ +0, /* tp_as_number */ +0, /* tp_as_sequence */ +0, /* tp_as_mapping */ +0, /* tp_hash */ +0, /* tp_call */ +0, /* tp_str */ +PyObject_GenericGetAttr, /* tp_getattro */ +0, /* tp_setattro */ +0, /* tp_as_buffer */ +Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */ +0, /* tp_doc */ +mbuf_traverse, /* tp_traverse */ +mbuf_clear /* tp_clear */ +}; +/****************************************************************************/ +/* MemoryView Object */ +/****************************************************************************/ +/* In the process of breaking reference cycles mbuf_release() can be +called before memory_release(). */ +#define BASE_INACCESSIBLE(mv) \ +(((PyMemoryViewObject *)mv)->flags&_Py_MEMORYVIEW_RELEASED || \ +((PyMemoryViewObject *)mv)->mbuf->flags&_Py_MANAGED_BUFFER_RELEASED) +#define CHECK_RELEASED(mv) \ +if (BASE_INACCESSIBLE(mv)) { \ +PyErr_SetString(PyExc_ValueError, \ +"operation forbidden on released memoryview object"); \ +return NULL; \ +} +#define CHECK_RELEASED_INT(mv) \ +if (BASE_INACCESSIBLE(mv)) { \ +PyErr_SetString(PyExc_ValueError, \ +"operation forbidden on released memoryview object"); \ +return -1; \ +} +#define CHECK_RESTRICTED(mv) \ +if (((PyMemoryViewObject *)(mv))->flags & _Py_MEMORYVIEW_RESTRICTED) { \ +PyErr_SetString(PyExc_ValueError, \ +"cannot create new view on restricted memoryview"); \ +return NULL; \ +} +#define CHECK_RESTRICTED_INT(mv) \ +if (((PyMemoryViewObject *)(mv))->flags & _Py_MEMORYVIEW_RESTRICTED) { \ +PyErr_SetString(PyExc_ValueError, \ +"cannot create new view on restricted memoryview"); \ +return -1; \ +} +/* See gh-92888. These macros signal that we need to check the memoryview +again due to possible read after frees. */ +#define CHECK_RELEASED_AGAIN(mv) CHECK_RELEASED(mv) +#define CHECK_RELEASED_INT_AGAIN(mv) CHECK_RELEASED_INT(mv) +#define CHECK_LIST_OR_TUPLE(v) \ +if (!PyList_Check(v) && !PyTuple_Check(v)) { \ +PyErr_SetString(PyExc_TypeError, \ +#v " must be a list or a tuple"); \ +return NULL; \ +} +#define VIEW_ADDR(mv) (&((PyMemoryViewObject *)mv)->view) +/* Check for the presence of suboffsets in the first dimension. */ +#define HAVE_PTR(suboffsets, dim) (suboffsets && suboffsets[dim] >= 0) +/* Adjust ptr if suboffsets are present. */ +#define ADJUST_PTR(ptr, suboffsets, dim) \ +(HAVE_PTR(suboffsets, dim) ? *((char**)ptr) + suboffsets[dim] : ptr) +/* Memoryview buffer properties */ +#define MV_C_CONTIGUOUS(flags) (flags&(_Py_MEMORYVIEW_SCALAR|_Py_MEMORYVIEW_C)) +#define MV_F_CONTIGUOUS(flags) \ +(flags&(_Py_MEMORYVIEW_SCALAR|_Py_MEMORYVIEW_FORTRAN)) +#define MV_ANY_CONTIGUOUS(flags) \ +(flags&(_Py_MEMORYVIEW_SCALAR|_Py_MEMORYVIEW_C|_Py_MEMORYVIEW_FORTRAN)) +/* Fast contiguity test. Caller must ensure suboffsets==NULL and ndim==1. */ +#define MV_CONTIGUOUS_NDIM1(view) \ +((view)->shape[0] == 1 || (view)->strides[0] == (view)->itemsize) +/* getbuffer() requests */ +#define REQ_INDIRECT(flags) ((flags&PyBUF_INDIRECT) == PyBUF_INDIRECT) +#define REQ_C_CONTIGUOUS(flags) ((flags&PyBUF_C_CONTIGUOUS) == PyBUF_C_CONTIGUOUS) +#define REQ_F_CONTIGUOUS(flags) ((flags&PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS) +#define REQ_ANY_CONTIGUOUS(flags) ((flags&PyBUF_ANY_CONTIGUOUS) == PyBUF_ANY_CONTIGUOUS) +#define REQ_STRIDES(flags) ((flags&PyBUF_STRIDES) == PyBUF_STRIDES) +#define REQ_SHAPE(flags) ((flags&PyBUF_ND) == PyBUF_ND) +#define REQ_WRITABLE(flags) (flags&PyBUF_WRITABLE) +#define REQ_FORMAT(flags) (flags&PyBUF_FORMAT) +/**************************************************************************/ +/* Copy memoryview buffers */ +/**************************************************************************/ +/* The functions in this section take a source and a destination buffer +with the same logical structure: format, itemsize, ndim and shape +are identical, with ndim > 0. +NOTE: All buffers are assumed to have PyBUF_FULL information, which +is the case for memoryviews! */ +/* Assumptions: ndim >= 1. The macro tests for a corner case that should +perhaps be explicitly forbidden in the PEP. */ +#define HAVE_SUBOFFSETS_IN_LAST_DIM(view) \ +(view->suboffsets && view->suboffsets[view->ndim-1] >= 0) +static inline int +last_dim_is_contiguous(const Py_buffer *dest, const Py_buffer *src) +{ +assert(dest->ndim > 0 && src->ndim > 0); +return (!HAVE_SUBOFFSETS_IN_LAST_DIM(dest) && +!HAVE_SUBOFFSETS_IN_LAST_DIM(src) && +dest->strides[dest->ndim-1] == dest->itemsize && +src->strides[src->ndim-1] == src->itemsize); +} +/* This is not a general function for determining format equivalence. +It is used in copy_single() and copy_buffer() to weed out non-matching +formats. Skipping the '@' character is specifically used in slice +assignments, where the lvalue is already known to have a single character +format. This is a performance hack that could be rewritten (if properly +benchmarked). */ +static inline int +equiv_format(const Py_buffer *dest, const Py_buffer *src) +{ +const char *dfmt, *sfmt; +assert(dest->format && src->format); +dfmt = dest->format[0] == '@' ? dest->format+1 : dest->format; +sfmt = src->format[0] == '@' ? src->format+1 : src->format; +if (strcmp(dfmt, sfmt) != 0 || +dest->itemsize != src->itemsize) { +return 0; +} +return 1; +} +/* Two shapes are equivalent if they are either equal or identical up +to a zero element at the same position. For example, in NumPy arrays +the shapes [1, 0, 5] and [1, 0, 7] are equivalent. */ +static inline int +equiv_shape(const Py_buffer *dest, const Py_buffer *src) +{ +int i; +if (dest->ndim != src->ndim) +return 0; +for (i = 0; i < dest->ndim; i++) { +if (dest->shape[i] != src->shape[i]) +return 0; +if (dest->shape[i] == 0) +break; +} +return 1; +} +/* Check that the logical structure of the destination and source buffers +is identical. */ +static int +equiv_structure(const Py_buffer *dest, const Py_buffer *src) +{ +if (!equiv_format(dest, src) || +!equiv_shape(dest, src)) { +PyErr_SetString(PyExc_ValueError, +"memoryview assignment: lvalue and rvalue have different " +"structures"); +return 0; +} +return 1; +} +/* Base case for recursive multi-dimensional copying. Contiguous arrays are +copied with very little overhead. Assumptions: ndim == 1, mem == NULL or +sizeof(mem) == shape[0] * itemsize. */ +static void +copy_base(const Py_ssize_t *shape, Py_ssize_t itemsize, +char *dptr, const Py_ssize_t *dstrides, const Py_ssize_t *dsuboffsets, +char *sptr, const Py_ssize_t *sstrides, const Py_ssize_t *ssuboffsets, +char *mem) +{ +if (mem == NULL) { /* contiguous */ +Py_ssize_t size = shape[0] * itemsize; +if (dptr + size < sptr || sptr + size < dptr) +memcpy(dptr, sptr, size); /* no overlapping */ +else +memmove(dptr, sptr, size); +} +else { +char *p; +Py_ssize_t i; +for (i=0, p=mem; i < shape[0]; p+=itemsize, sptr+=sstrides[0], i++) { +char *xsptr = ADJUST_PTR(sptr, ssuboffsets, 0); +memcpy(p, xsptr, itemsize); +} +for (i=0, p=mem; i < shape[0]; p+=itemsize, dptr+=dstrides[0], i++) { +char *xdptr = ADJUST_PTR(dptr, dsuboffsets, 0); +memcpy(xdptr, p, itemsize); +} +} +} +/* Recursively copy a source buffer to a destination buffer. The two buffers +have the same ndim, shape and itemsize. */ +static void +copy_rec(const Py_ssize_t *shape, Py_ssize_t ndim, Py_ssize_t itemsize, +char *dptr, const Py_ssize_t *dstrides, const Py_ssize_t *dsuboffsets, +char *sptr, const Py_ssize_t *sstrides, const Py_ssize_t *ssuboffsets, +char *mem) +{ +Py_ssize_t i; +assert(ndim >= 1); +if (ndim == 1) { +copy_base(shape, itemsize, +dptr, dstrides, dsuboffsets, +sptr, sstrides, ssuboffsets, +mem); +return; +} +for (i = 0; i < shape[0]; dptr+=dstrides[0], sptr+=sstrides[0], i++) { +char *xdptr = ADJUST_PTR(dptr, dsuboffsets, 0); +char *xsptr = ADJUST_PTR(sptr, ssuboffsets, 0); +copy_rec(shape+1, ndim-1, itemsize, +xdptr, dstrides+1, dsuboffsets ? dsuboffsets+1 : NULL, +xsptr, sstrides+1, ssuboffsets ? ssuboffsets+1 : NULL, +mem); +} +} +/* Faster copying of one-dimensional arrays. */ +static int +copy_single(PyMemoryViewObject *self, const Py_buffer *dest, const Py_buffer *src) +{ +CHECK_RELEASED_INT_AGAIN(self); +char *mem = NULL; +assert(dest->ndim == 1); +if (!equiv_structure(dest, src)) +return -1; +if (!last_dim_is_contiguous(dest, src)) { +mem = PyMem_Malloc(dest->shape[0] * dest->itemsize); +if (mem == NULL) { +PyErr_NoMemory(); +return -1; +} +} +copy_base(dest->shape, dest->itemsize, +dest->buf, dest->strides, dest->suboffsets, +src->buf, src->strides, src->suboffsets, +mem); +if (mem) +PyMem_Free(mem); +return 0; +} +/* Recursively copy src to dest. Both buffers must have the same basic +structure. Copying is atomic, the function never fails with a partial +copy. */ +static int +copy_buffer(const Py_buffer *dest, const Py_buffer *src) +{ +char *mem = NULL; +assert(dest->ndim > 0); +if (!equiv_structure(dest, src)) +return -1; +if (!last_dim_is_contiguous(dest, src)) { +mem = PyMem_Malloc(dest->shape[dest->ndim-1] * dest->itemsize); +if (mem == NULL) { +PyErr_NoMemory(); +return -1; +} +} +copy_rec(dest->shape, dest->ndim, dest->itemsize, +dest->buf, dest->strides, dest->suboffsets, +src->buf, src->strides, src->suboffsets, +mem); +if (mem) +PyMem_Free(mem); +return 0; +} +/* Initialize strides for a C-contiguous array. */ +static inline void +init_strides_from_shape(Py_buffer *view) +{ +Py_ssize_t i; +assert(view->ndim > 0); +view->strides[view->ndim-1] = view->itemsize; +for (i = view->ndim-2; i >= 0; i--) +view->strides[i] = view->strides[i+1] * view->shape[i+1]; +} +/* Initialize strides for a Fortran-contiguous array. */ +static inline void +init_fortran_strides_from_shape(Py_buffer *view) +{ +Py_ssize_t i; +assert(view->ndim > 0); +view->strides[0] = view->itemsize; +for (i = 1; i < view->ndim; i++) +view->strides[i] = view->strides[i-1] * view->shape[i-1]; +} +/* Copy src to a contiguous representation. order is one of 'C', 'F' (Fortran) +or 'A' (Any). Assumptions: src has PyBUF_FULL information, src->ndim >= 1, +len(mem) == src->len. */ +static int +buffer_to_contiguous(char *mem, const Py_buffer *src, char order) +{ +Py_buffer dest; +Py_ssize_t *strides; +int ret; +assert(src->ndim >= 1); +assert(src->shape != NULL); +assert(src->strides != NULL); +strides = PyMem_Malloc(src->ndim * (sizeof *src->strides)); +if (strides == NULL) { +PyErr_NoMemory(); +return -1; +} +/* initialize dest */ +dest = *src; +dest.buf = mem; +/* shape is constant and shared: the logical representation of the +array is unaltered. */ +/* The physical representation determined by strides (and possibly +suboffsets) may change. */ +dest.strides = strides; +if (order == 'C' || order == 'A') { +init_strides_from_shape(&dest); +} +else { +init_fortran_strides_from_shape(&dest); +} +dest.suboffsets = NULL; +ret = copy_buffer(&dest, src); +PyMem_Free(strides); +return ret; +} +/****************************************************************************/ +/* Constructors */ +/****************************************************************************/ +/* Initialize values that are shared with the managed buffer. */ +static inline void +init_shared_values(Py_buffer *dest, const Py_buffer *src) +{ +dest->obj = src->obj; +dest->buf = src->buf; +dest->len = src->len; +dest->itemsize = src->itemsize; +dest->readonly = src->readonly; +dest->format = src->format ? src->format : "B"; +dest->internal = src->internal; +} +/* Copy shape and strides. Reconstruct missing values. */ +static void +init_shape_strides(Py_buffer *dest, const Py_buffer *src) +{ +Py_ssize_t i; +if (src->ndim == 0) { +dest->shape = NULL; +dest->strides = NULL; +return; +} +if (src->ndim == 1) { +dest->shape[0] = src->shape ? src->shape[0] : src->len / src->itemsize; +dest->strides[0] = src->strides ? src->strides[0] : src->itemsize; +return; +} +for (i = 0; i < src->ndim; i++) +dest->shape[i] = src->shape[i]; +if (src->strides) { +for (i = 0; i < src->ndim; i++) +dest->strides[i] = src->strides[i]; +} +else { +init_strides_from_shape(dest); +} +} +static inline void +init_suboffsets(Py_buffer *dest, const Py_buffer *src) +{ +Py_ssize_t i; +if (src->suboffsets == NULL) { +dest->suboffsets = NULL; +return; +} +for (i = 0; i < src->ndim; i++) +dest->suboffsets[i] = src->suboffsets[i]; +} +/* len = product(shape) * itemsize */ +static inline void +init_len(Py_buffer *view) +{ +Py_ssize_t i, len; +len = 1; +for (i = 0; i < view->ndim; i++) +len *= view->shape[i]; +len *= view->itemsize; +view->len = len; +} +/* Initialize memoryview buffer properties. */ +static void +init_flags(PyMemoryViewObject *mv) +{ +const Py_buffer *view = &mv->view; +int flags = 0; +switch (view->ndim) { +case 0: +flags |= (_Py_MEMORYVIEW_SCALAR|_Py_MEMORYVIEW_C| +_Py_MEMORYVIEW_FORTRAN); +break; +case 1: +if (MV_CONTIGUOUS_NDIM1(view)) +flags |= (_Py_MEMORYVIEW_C|_Py_MEMORYVIEW_FORTRAN); +break; +default: +if (PyBuffer_IsContiguous(view, 'C')) +flags |= _Py_MEMORYVIEW_C; +if (PyBuffer_IsContiguous(view, 'F')) +flags |= _Py_MEMORYVIEW_FORTRAN; +break; +} +if (view->suboffsets) { +flags |= _Py_MEMORYVIEW_PIL; +flags &= ~(_Py_MEMORYVIEW_C|_Py_MEMORYVIEW_FORTRAN); +} +mv->flags = flags; +} +/* Allocate a new memoryview and perform basic initialization. New memoryviews +are exclusively created through the mbuf_add functions. */ +static inline PyMemoryViewObject * +memory_alloc(int ndim) +{ +PyMemoryViewObject *mv; +mv = (PyMemoryViewObject *) +PyObject_GC_NewVar(PyMemoryViewObject, &PyMemoryView_Type, 3*ndim); +if (mv == NULL) +return NULL; +mv->mbuf = NULL; +mv->hash = -1; +mv->flags = 0; +mv->exports = 0; +mv->view.ndim = ndim; +mv->view.shape = mv->ob_array; +mv->view.strides = mv->ob_array + ndim; +mv->view.suboffsets = mv->ob_array + 2 * ndim; +mv->weakreflist = NULL; +_PyObject_GC_TRACK(mv); +return mv; +} +/* +Return a new memoryview that is registered with mbuf. If src is NULL, +use mbuf->master as the underlying buffer. Otherwise, use src. +The new memoryview has full buffer information: shape and strides +are always present, suboffsets as needed. Arrays are copied to +the memoryview's ob_array field. +*/ +static PyObject * +mbuf_add_view(_PyManagedBufferObject *mbuf, const Py_buffer *src) +{ +PyMemoryViewObject *mv; +Py_buffer *dest; +if (src == NULL) +src = &mbuf->master; +if (src->ndim > PyBUF_MAX_NDIM) { +PyErr_SetString(PyExc_ValueError, +"memoryview: number of dimensions must not exceed " +Py_STRINGIFY(PyBUF_MAX_NDIM)); +return NULL; +} +mv = memory_alloc(src->ndim); +if (mv == NULL) +return NULL; +dest = &mv->view; +init_shared_values(dest, src); +init_shape_strides(dest, src); +init_suboffsets(dest, src); +init_flags(mv); +mv->mbuf = (_PyManagedBufferObject*)Py_NewRef(mbuf); +mbuf->exports++; +return (PyObject *)mv; +} +/* Register an incomplete view: shape, strides, suboffsets and flags still +need to be initialized. Use 'ndim' instead of src->ndim to determine the +size of the memoryview's ob_array. +Assumption: ndim <= PyBUF_MAX_NDIM. */ +static PyObject * +mbuf_add_incomplete_view(_PyManagedBufferObject *mbuf, const Py_buffer *src, +int ndim) +{ +PyMemoryViewObject *mv; +Py_buffer *dest; +if (src == NULL) +src = &mbuf->master; +assert(ndim <= PyBUF_MAX_NDIM); +mv = memory_alloc(ndim); +if (mv == NULL) +return NULL; +dest = &mv->view; +init_shared_values(dest, src); +mv->mbuf = (_PyManagedBufferObject*)Py_NewRef(mbuf); +mbuf->exports++; +return (PyObject *)mv; +} +/* Expose a raw memory area as a view of contiguous bytes. flags can be +PyBUF_READ or PyBUF_WRITE. view->format is set to "B" (unsigned bytes). +The memoryview has complete buffer information. */ +PyObject * +PyMemoryView_FromMemory(char *mem, Py_ssize_t size, int flags) +{ +_PyManagedBufferObject *mbuf; +PyObject *mv; +int readonly; +assert(mem != NULL); +assert(flags == PyBUF_READ || flags == PyBUF_WRITE); +mbuf = mbuf_alloc(); +if (mbuf == NULL) +return NULL; +readonly = (flags == PyBUF_WRITE) ? 0 : 1; +(void)PyBuffer_FillInfo(&mbuf->master, NULL, mem, size, readonly, +PyBUF_FULL_RO); +mv = mbuf_add_view(mbuf, NULL); +Py_DECREF(mbuf); +return mv; +} +/* Create a memoryview from a given Py_buffer. For simple byte views, +PyMemoryView_FromMemory() should be used instead. +This function is the only entry point that can create a master buffer +without full information. Because of this fact init_shape_strides() +must be able to reconstruct missing values. */ +PyObject * +PyMemoryView_FromBuffer(const Py_buffer *info) +{ +_PyManagedBufferObject *mbuf; +PyObject *mv; +if (info->buf == NULL) { +PyErr_SetString(PyExc_ValueError, +"PyMemoryView_FromBuffer(): info->buf must not be NULL"); +return NULL; +} +mbuf = mbuf_alloc(); +if (mbuf == NULL) +return NULL; +/* info->obj is either NULL or a borrowed reference. This reference +should not be decremented in PyBuffer_Release(). */ +mbuf->master = *info; +mbuf->master.obj = NULL; +mv = mbuf_add_view(mbuf, NULL); +Py_DECREF(mbuf); +return mv; +} +/* Create a memoryview from an object that implements the buffer protocol, +using the given flags. +If the object is a memoryview, the new memoryview must be registered +with the same managed buffer. Otherwise, a new managed buffer is created. */ +static PyObject * +PyMemoryView_FromObjectAndFlags(PyObject *v, int flags) +{ +_PyManagedBufferObject *mbuf; +if (PyMemoryView_Check(v)) { +PyMemoryViewObject *mv = (PyMemoryViewObject *)v; +CHECK_RELEASED(mv); +CHECK_RESTRICTED(mv); +return mbuf_add_view(mv->mbuf, &mv->view); +} +else if (PyObject_CheckBuffer(v)) { +PyObject *ret; +mbuf = (_PyManagedBufferObject *)_PyManagedBuffer_FromObject(v, flags); +if (mbuf == NULL) +return NULL; +ret = mbuf_add_view(mbuf, NULL); +Py_DECREF(mbuf); +return ret; +} +PyErr_Format(PyExc_TypeError, +"memoryview: a bytes-like object is required, not '%.200s'", +Py_TYPE(v)->tp_name); +return NULL; +} +/* Create a memoryview from an object that implements the buffer protocol, +using the given flags. +If the object is a memoryview, the new memoryview must be registered +with the same managed buffer. Otherwise, a new managed buffer is created. */ +PyObject * +_PyMemoryView_FromBufferProc(PyObject *v, int flags, getbufferproc bufferproc) +{ +_PyManagedBufferObject *mbuf = mbuf_alloc(); +if (mbuf == NULL) +return NULL; +int res = bufferproc(v, &mbuf->master, flags); +if (res < 0) { +mbuf->master.obj = NULL; +Py_DECREF(mbuf); +return NULL; +} +PyObject *ret = mbuf_add_view(mbuf, NULL); +Py_DECREF(mbuf); +return ret; +} +/* Create a memoryview from an object that implements the buffer protocol. +If the object is a memoryview, the new memoryview must be registered +with the same managed buffer. Otherwise, a new managed buffer is created. */ +PyObject * +PyMemoryView_FromObject(PyObject *v) +{ +return PyMemoryView_FromObjectAndFlags(v, PyBUF_FULL_RO); +} +/* Copy the format string from a base object that might vanish. */ +static int +mbuf_copy_format(_PyManagedBufferObject *mbuf, const char *fmt) +{ +if (fmt != NULL) { +char *cp = PyMem_Malloc(strlen(fmt)+1); +if (cp == NULL) { +PyErr_NoMemory(); +return -1; +} +mbuf->master.format = strcpy(cp, fmt); +mbuf->flags |= _Py_MANAGED_BUFFER_FREE_FORMAT; +} +return 0; +} +/* +Return a memoryview that is based on a contiguous copy of src. +Assumptions: src has PyBUF_FULL_RO information, src->ndim > 0. +Ownership rules: +1) As usual, the returned memoryview has a private copy +of src->shape, src->strides and src->suboffsets. +2) src->format is copied to the master buffer and released +in mbuf_dealloc(). The releasebufferproc of the bytes +object is NULL, so it does not matter that mbuf_release() +passes the altered format pointer to PyBuffer_Release(). +*/ +static PyObject * +memory_from_contiguous_copy(const Py_buffer *src, char order) +{ +_PyManagedBufferObject *mbuf; +PyMemoryViewObject *mv; +PyObject *bytes; +Py_buffer *dest; +int i; +assert(src->ndim > 0); +assert(src->shape != NULL); +bytes = PyBytes_FromStringAndSize(NULL, src->len); +if (bytes == NULL) +return NULL; +mbuf = (_PyManagedBufferObject *)_PyManagedBuffer_FromObject(bytes, PyBUF_FULL_RO); +Py_DECREF(bytes); +if (mbuf == NULL) +return NULL; +if (mbuf_copy_format(mbuf, src->format) < 0) { +Py_DECREF(mbuf); +return NULL; +} +mv = (PyMemoryViewObject *)mbuf_add_incomplete_view(mbuf, NULL, src->ndim); +Py_DECREF(mbuf); +if (mv == NULL) +return NULL; +dest = &mv->view; +/* shared values are initialized correctly except for itemsize */ +dest->itemsize = src->itemsize; +/* shape and strides */ +for (i = 0; i < src->ndim; i++) { +dest->shape[i] = src->shape[i]; +} +if (order == 'C' || order == 'A') { +init_strides_from_shape(dest); +} +else { +init_fortran_strides_from_shape(dest); +} +/* suboffsets */ +dest->suboffsets = NULL; +/* flags */ +init_flags(mv); +if (copy_buffer(dest, src) < 0) { +Py_DECREF(mv); +return NULL; +} +return (PyObject *)mv; +} +/* +Return a new memoryview object based on a contiguous exporter with +buffertype={PyBUF_READ, PyBUF_WRITE} and order={'C', 'F'ortran, or 'A'ny}. +The logical structure of the input and output buffers is the same +(i.e. tolist(input) == tolist(output)), but the physical layout in +memory can be explicitly chosen. +As usual, if buffertype=PyBUF_WRITE, the exporter's buffer must be writable, +otherwise it may be writable or read-only. +If the exporter is already contiguous with the desired target order, +the memoryview will be directly based on the exporter. +Otherwise, if the buffertype is PyBUF_READ, the memoryview will be +based on a new bytes object. If order={'C', 'A'ny}, use 'C' order, +'F'ortran order otherwise. +*/ +PyObject * +PyMemoryView_GetContiguous(PyObject *obj, int buffertype, char order) +{ +PyMemoryViewObject *mv; +PyObject *ret; +Py_buffer *view; +assert(buffertype == PyBUF_READ || buffertype == PyBUF_WRITE); +assert(order == 'C' || order == 'F' || order == 'A'); +mv = (PyMemoryViewObject *)PyMemoryView_FromObject(obj); +if (mv == NULL) +return NULL; +view = &mv->view; +if (buffertype == PyBUF_WRITE && view->readonly) { +PyErr_SetString(PyExc_BufferError, +"underlying buffer is not writable"); +Py_DECREF(mv); +return NULL; +} +if (PyBuffer_IsContiguous(view, order)) +return (PyObject *)mv; +if (buffertype == PyBUF_WRITE) { +PyErr_SetString(PyExc_BufferError, +"writable contiguous buffer requested " +"for a non-contiguous object."); +Py_DECREF(mv); +return NULL; +} +ret = memory_from_contiguous_copy(view, order); +Py_DECREF(mv); +return ret; +} +/*[clinic input] +@classmethod +memoryview.__new__ +object: object +Create a new memoryview object which references the given object. +[clinic start generated code]*/ +static PyObject * +memoryview_impl(PyTypeObject *type, PyObject *object) +/*[clinic end generated code: output=7de78e184ed66db8 input=f04429eb0bdf8c6e]*/ +{ +return PyMemoryView_FromObject(object); +} +/*[clinic input] +@classmethod +memoryview._from_flags +object: object +flags: int +Create a new memoryview object which references the given object. +[clinic start generated code]*/ +static PyObject * +memoryview__from_flags_impl(PyTypeObject *type, PyObject *object, int flags) +/*[clinic end generated code: output=bf71f9906c266ee2 input=f5f82fd0e744356b]*/ +{ +return PyMemoryView_FromObjectAndFlags(object, flags); +} +/****************************************************************************/ +/* Previously in abstract.c */ +/****************************************************************************/ +typedef struct { +Py_buffer view; +Py_ssize_t array[1]; +} Py_buffer_full; +int +PyBuffer_ToContiguous(void *buf, const Py_buffer *src, Py_ssize_t len, char order) +{ +Py_buffer_full *fb = NULL; +int ret; +assert(order == 'C' || order == 'F' || order == 'A'); +if (len != src->len) { +PyErr_SetString(PyExc_ValueError, +"PyBuffer_ToContiguous: len != view->len"); +return -1; +} +if (PyBuffer_IsContiguous(src, order)) { +memcpy((char *)buf, src->buf, len); +return 0; +} +/* buffer_to_contiguous() assumes PyBUF_FULL */ +fb = PyMem_Malloc(sizeof *fb + 3 * src->ndim * (sizeof *fb->array)); +if (fb == NULL) { +PyErr_NoMemory(); +return -1; +} +fb->view.ndim = src->ndim; +fb->view.shape = fb->array; +fb->view.strides = fb->array + src->ndim; +fb->view.suboffsets = fb->array + 2 * src->ndim; +init_shared_values(&fb->view, src); +init_shape_strides(&fb->view, src); +init_suboffsets(&fb->view, src); +src = &fb->view; +ret = buffer_to_contiguous(buf, src, order); +PyMem_Free(fb); +return ret; +} +static inline Py_ssize_t +get_exports(PyMemoryViewObject *buf) +{ +#ifdef Py_GIL_DISABLED +return _Py_atomic_load_ssize_relaxed(&buf->exports); +#else +return buf->exports; +#endif +} +/****************************************************************************/ +/* Release/GC management */ +/****************************************************************************/ +/* Inform the managed buffer that this particular memoryview will not access +the underlying buffer again. If no other memoryviews are registered with +the managed buffer, the underlying buffer is released instantly and +marked as inaccessible for both the memoryview and the managed buffer. */ +static void +_memory_release(PyMemoryViewObject *self) +{ +assert(get_exports(self) == 0); +if (self->flags & _Py_MEMORYVIEW_RELEASED) +return; +self->flags |= _Py_MEMORYVIEW_RELEASED; +assert(self->mbuf->exports > 0); +if (--self->mbuf->exports == 0) { +mbuf_release(self->mbuf); +} +} +/*[clinic input] +memoryview.release +Release the underlying buffer exposed by the memoryview object. +[clinic start generated code]*/ +static PyObject * +memoryview_release_impl(PyMemoryViewObject *self) +/*[clinic end generated code: output=d0b7e3ba95b7fcb9 input=bc71d1d51f4a52f0]*/ +{ +Py_ssize_t exports = get_exports(self); +if (exports == 0) { +_memory_release(self); +Py_RETURN_NONE; +} +if (exports > 0) { +PyErr_Format(PyExc_BufferError, +"memoryview has %zd exported buffer%s", exports, +exports==1 ? "" : "s"); +return NULL; +} +PyErr_SetString(PyExc_SystemError, +"memoryview: negative export count"); +return NULL; +} +static void +memory_dealloc(PyObject *_self) +{ +PyMemoryViewObject *self = (PyMemoryViewObject *)_self; +assert(get_exports(self) == 0); +_PyObject_GC_UNTRACK(self); +_memory_release(self); +Py_CLEAR(self->mbuf); +if (self->weakreflist != NULL) +PyObject_ClearWeakRefs((PyObject *) self); +PyObject_GC_Del(self); +} +static int +memory_traverse(PyObject *_self, visitproc visit, void *arg) +{ +PyMemoryViewObject *self = (PyMemoryViewObject *)_self; +Py_VISIT(self->mbuf); +return 0; +} +static int +memory_clear(PyObject *_self) +{ +PyMemoryViewObject *self = (PyMemoryViewObject *)_self; +if (get_exports(self) == 0) { +_memory_release(self); +Py_CLEAR(self->mbuf); +} +return 0; +} +static PyObject * +memory_enter(PyObject *self, PyObject *args) +{ +CHECK_RELEASED(self); +return Py_NewRef(self); +} +static PyObject * +memory_exit(PyObject *self, PyObject *args) +{ +return memoryview_release_impl((PyMemoryViewObject *)self); +} +/****************************************************************************/ +/* Casting format and shape */ +/****************************************************************************/ +#define IS_BYTE_FORMAT(f) (f == 'b' || f == 'B' || f == 'c') +static inline Py_ssize_t +get_native_fmtchar(char *result, const char *fmt) +{ +Py_ssize_t size = -1; +if (fmt[0] == '@') fmt++; +switch (fmt[0]) { +case 'c': case 'b': case 'B': size = sizeof(char); break; +case 'h': case 'H': size = sizeof(short); break; +case 'i': case 'I': size = sizeof(int); break; +case 'l': case 'L': size = sizeof(long); break; +case 'q': case 'Q': size = sizeof(long long); break; +case 'n': case 'N': size = sizeof(Py_ssize_t); break; +case 'f': size = sizeof(float); break; +case 'd': size = sizeof(double); break; +case 'e': size = sizeof(float) / 2; break; +case '?': size = sizeof(_Bool); break; +case 'P': size = sizeof(void *); break; +} +if (size > 0 && fmt[1] == '\0') { +*result = fmt[0]; +return size; +} +return -1; +} +static inline const char * +get_native_fmtstr(const char *fmt) +{ +int at = 0; +if (fmt[0] == '@') { +at = 1; +fmt++; +} +if (fmt[0] == '\0' || fmt[1] != '\0') { +return NULL; +} +#define RETURN(s) do { return at ? "@" s : s; } while (0) +switch (fmt[0]) { +case 'c': RETURN("c"); +case 'b': RETURN("b"); +case 'B': RETURN("B"); +case 'h': RETURN("h"); +case 'H': RETURN("H"); +case 'i': RETURN("i"); +case 'I': RETURN("I"); +case 'l': RETURN("l"); +case 'L': RETURN("L"); +case 'q': RETURN("q"); +case 'Q': RETURN("Q"); +case 'n': RETURN("n"); +case 'N': RETURN("N"); +case 'f': RETURN("f"); +case 'd': RETURN("d"); +case 'e': RETURN("e"); +case '?': RETURN("?"); +case 'P': RETURN("P"); +} +return NULL; +} +/* Cast a memoryview's data type to 'format'. The input array must be +C-contiguous. At least one of input-format, output-format must have +byte size. The output array is 1-D, with the same byte length as the +input array. Thus, view->len must be a multiple of the new itemsize. */ +static int +cast_to_1D(PyMemoryViewObject *mv, PyObject *format) +{ +Py_buffer *view = &mv->view; +PyObject *asciifmt; +char srcchar, destchar; +Py_ssize_t itemsize; +int ret = -1; +assert(view->ndim >= 1); +assert(Py_SIZE(mv) == 3*view->ndim); +assert(view->shape == mv->ob_array); +assert(view->strides == mv->ob_array + view->ndim); +assert(view->suboffsets == mv->ob_array + 2*view->ndim); +asciifmt = PyUnicode_AsASCIIString(format); +if (asciifmt == NULL) +return ret; +itemsize = get_native_fmtchar(&destchar, PyBytes_AS_STRING(asciifmt)); +if (itemsize < 0) { +PyErr_SetString(PyExc_ValueError, +"memoryview: destination format must be a native single " +"character format prefixed with an optional '@'"); +goto out; +} +if ((get_native_fmtchar(&srcchar, view->format) < 0 || +!IS_BYTE_FORMAT(srcchar)) && !IS_BYTE_FORMAT(destchar)) { +PyErr_SetString(PyExc_TypeError, +"memoryview: cannot cast between two non-byte formats"); +goto out; +} +if (view->len % itemsize) { +PyErr_SetString(PyExc_TypeError, +"memoryview: length is not a multiple of itemsize"); +goto out; +} +view->format = (char *)get_native_fmtstr(PyBytes_AS_STRING(asciifmt)); +if (view->format == NULL) { +/* NOT_REACHED: get_native_fmtchar() already validates the format. */ +PyErr_SetString(PyExc_RuntimeError, +"memoryview: internal error"); +goto out; +} +view->itemsize = itemsize; +view->ndim = 1; +view->shape[0] = view->len / view->itemsize; +view->strides[0] = view->itemsize; +view->suboffsets = NULL; +init_flags(mv); +ret = 0; +out: +Py_DECREF(asciifmt); +return ret; +} +/* The memoryview must have space for 3*len(seq) elements. */ +static Py_ssize_t +copy_shape(Py_ssize_t *shape, const PyObject *seq, Py_ssize_t ndim, +Py_ssize_t itemsize) +{ +Py_ssize_t x, i; +Py_ssize_t len = itemsize; +for (i = 0; i < ndim; i++) { +PyObject *tmp = PySequence_Fast_GET_ITEM(seq, i); +if (!PyLong_Check(tmp)) { +PyErr_SetString(PyExc_TypeError, +"memoryview.cast(): elements of shape must be integers"); +return -1; +} +x = PyLong_AsSsize_t(tmp); +if (x == -1 && PyErr_Occurred()) { +return -1; +} +if (x <= 0) { +/* In general elements of shape may be 0, but not for casting. */ +PyErr_Format(PyExc_ValueError, +"memoryview.cast(): elements of shape must be integers > 0"); +return -1; +} +if (x > PY_SSIZE_T_MAX / len) { +PyErr_Format(PyExc_ValueError, +"memoryview.cast(): product(shape) > SSIZE_MAX"); +return -1; +} +len *= x; +shape[i] = x; +} +return len; +} +/* Cast a 1-D array to a new shape. The result array will be C-contiguous. +If the result array does not have exactly the same byte length as the +input array, raise ValueError. */ +static int +cast_to_ND(PyMemoryViewObject *mv, const PyObject *shape, int ndim) +{ +Py_buffer *view = &mv->view; +Py_ssize_t len; +assert(view->ndim == 1); /* ndim from cast_to_1D() */ +assert(Py_SIZE(mv) == 3*(ndim==0?1:ndim)); /* ndim of result array */ +assert(view->shape == mv->ob_array); +assert(view->strides == mv->ob_array + (ndim==0?1:ndim)); +assert(view->suboffsets == NULL); +view->ndim = ndim; +if (view->ndim == 0) { +view->shape = NULL; +view->strides = NULL; +len = view->itemsize; +} +else { +len = copy_shape(view->shape, shape, ndim, view->itemsize); +if (len < 0) +return -1; +init_strides_from_shape(view); +} +if (view->len != len) { +PyErr_SetString(PyExc_TypeError, +"memoryview: product(shape) * itemsize != buffer size"); +return -1; +} +init_flags(mv); +return 0; +} +static int +zero_in_shape(PyMemoryViewObject *mv) +{ +Py_buffer *view = &mv->view; +Py_ssize_t i; +for (i = 0; i < view->ndim; i++) +if (view->shape[i] == 0) +return 1; +return 0; +} +/* +Cast a copy of 'self' to a different view. The input view must +be C-contiguous. The function always casts the input view to a +1-D output according to 'format'. At least one of input-format, +output-format must have byte size. +If 'shape' is given, the 1-D view from the previous step will +be cast to a C-contiguous view with new shape and strides. +All casts must result in views that will have the exact byte +size of the original input. Otherwise, an error is raised. +*/ +/*[clinic input] +memoryview.cast +format: unicode +shape: object = NULL +Cast a memoryview to a new format or shape. +[clinic start generated code]*/ +static PyObject * +memoryview_cast_impl(PyMemoryViewObject *self, PyObject *format, +PyObject *shape) +/*[clinic end generated code: output=bae520b3a389cbab input=138936cc9041b1a3]*/ +{ +PyMemoryViewObject *mv = NULL; +Py_ssize_t ndim = 1; +CHECK_RELEASED(self); +CHECK_RESTRICTED(self); +if (!MV_C_CONTIGUOUS(self->flags)) { +PyErr_SetString(PyExc_TypeError, +"memoryview: casts are restricted to C-contiguous views"); +return NULL; +} +if ((shape || self->view.ndim != 1) && zero_in_shape(self)) { +PyErr_SetString(PyExc_TypeError, +"memoryview: cannot cast view with zeros in shape or strides"); +return NULL; +} +if (shape) { +CHECK_LIST_OR_TUPLE(shape) +ndim = PySequence_Fast_GET_SIZE(shape); +if (ndim > PyBUF_MAX_NDIM) { +PyErr_SetString(PyExc_ValueError, +"memoryview: number of dimensions must not exceed " +Py_STRINGIFY(PyBUF_MAX_NDIM)); +return NULL; +} +if (self->view.ndim != 1 && ndim != 1) { +PyErr_SetString(PyExc_TypeError, +"memoryview: cast must be 1D -> ND or ND -> 1D"); +return NULL; +} +} +mv = (PyMemoryViewObject *) +mbuf_add_incomplete_view(self->mbuf, &self->view, ndim==0 ? 1 : (int)ndim); +if (mv == NULL) +return NULL; +if (cast_to_1D(mv, format) < 0) +goto error; +if (shape && cast_to_ND(mv, shape, (int)ndim) < 0) +goto error; +return (PyObject *)mv; +error: +Py_DECREF(mv); +return NULL; +} +/*[clinic input] +memoryview.toreadonly +Return a readonly version of the memoryview. +[clinic start generated code]*/ +static PyObject * +memoryview_toreadonly_impl(PyMemoryViewObject *self) +/*[clinic end generated code: output=2c7e056f04c99e62 input=dc06d20f19ba236f]*/ +{ +CHECK_RELEASED(self); +CHECK_RESTRICTED(self); +/* Even if self is already readonly, we still need to create a new +* object for .release() to work correctly. +*/ +self = (PyMemoryViewObject *) mbuf_add_view(self->mbuf, &self->view); +if (self != NULL) { +self->view.readonly = 1; +}; +return (PyObject *) self; +} +/**************************************************************************/ +/* getbuffer */ +/**************************************************************************/ +static int +memory_getbuf(PyObject *_self, Py_buffer *view, int flags) +{ +PyMemoryViewObject *self = (PyMemoryViewObject *)_self; +Py_buffer *base = &self->view; +int baseflags = self->flags; +CHECK_RELEASED_INT(self); +CHECK_RESTRICTED_INT(self); +/* start with complete information */ +*view = *base; +view->obj = NULL; +if (REQ_WRITABLE(flags) && base->readonly) { +PyErr_SetString(PyExc_BufferError, +"memoryview: underlying buffer is not writable"); +return -1; +} +if (!REQ_FORMAT(flags)) { +/* NULL indicates that the buffer's data type has been cast to 'B'. +view->itemsize is the _previous_ itemsize. If shape is present, +the equality product(shape) * itemsize = len still holds at this +point. The equality calcsize(format) = itemsize does _not_ hold +from here on! */ +view->format = NULL; +} +if (REQ_C_CONTIGUOUS(flags) && !MV_C_CONTIGUOUS(baseflags)) { +PyErr_SetString(PyExc_BufferError, +"memoryview: underlying buffer is not C-contiguous"); +return -1; +} +if (REQ_F_CONTIGUOUS(flags) && !MV_F_CONTIGUOUS(baseflags)) { +PyErr_SetString(PyExc_BufferError, +"memoryview: underlying buffer is not Fortran contiguous"); +return -1; +} +if (REQ_ANY_CONTIGUOUS(flags) && !MV_ANY_CONTIGUOUS(baseflags)) { +PyErr_SetString(PyExc_BufferError, +"memoryview: underlying buffer is not contiguous"); +return -1; +} +if (!REQ_INDIRECT(flags) && (baseflags & _Py_MEMORYVIEW_PIL)) { +PyErr_SetString(PyExc_BufferError, +"memoryview: underlying buffer requires suboffsets"); +return -1; +} +if (!REQ_STRIDES(flags)) { +if (!MV_C_CONTIGUOUS(baseflags)) { +PyErr_SetString(PyExc_BufferError, +"memoryview: underlying buffer is not C-contiguous"); +return -1; +} +view->strides = NULL; +} +if (!REQ_SHAPE(flags)) { +/* PyBUF_SIMPLE or PyBUF_WRITABLE: at this point buf is C-contiguous, +so base->buf = ndbuf->data. */ +if (view->format != NULL) { +/* PyBUF_SIMPLE|PyBUF_FORMAT and PyBUF_WRITABLE|PyBUF_FORMAT do +not make sense. */ +PyErr_Format(PyExc_BufferError, +"memoryview: cannot cast to unsigned bytes if the format flag " +"is present"); +return -1; +} +/* product(shape) * itemsize = len and calcsize(format) = itemsize +do _not_ hold from here on! */ +view->ndim = 1; +view->shape = NULL; +} +view->obj = Py_NewRef(self); +#ifdef Py_GIL_DISABLED +_Py_atomic_add_ssize(&self->exports, 1); +#else +self->exports++; +#endif +return 0; +} +static void +memory_releasebuf(PyObject *_self, Py_buffer *view) +{ +PyMemoryViewObject *self = (PyMemoryViewObject *)_self; +#ifdef Py_GIL_DISABLED +_Py_atomic_add_ssize(&self->exports, -1); +#else +self->exports--; +#endif +return; +/* PyBuffer_Release() decrements view->obj after this function returns. */ +} +/* Buffer methods */ +static PyBufferProcs memory_as_buffer = { +memory_getbuf, /* bf_getbuffer */ +memory_releasebuf, /* bf_releasebuffer */ +}; +/****************************************************************************/ +/* Optimized pack/unpack for all native format specifiers */ +/****************************************************************************/ +/* +Fix exceptions: +1) Include format string in the error message. +2) OverflowError -> ValueError. +3) The error message from PyNumber_Index() is not ideal. +*/ +static int +type_error_int(const char *fmt) +{ +PyErr_Format(PyExc_TypeError, +"memoryview: invalid type for format '%s'", fmt); +return -1; +} +static int +value_error_int(const char *fmt) +{ +PyErr_Format(PyExc_ValueError, +"memoryview: invalid value for format '%s'", fmt); +return -1; +} +static int +fix_error_int(const char *fmt) +{ +assert(PyErr_Occurred()); +if (PyErr_ExceptionMatches(PyExc_TypeError)) { +PyErr_Clear(); +return type_error_int(fmt); +} +else if (PyErr_ExceptionMatches(PyExc_OverflowError) || +PyErr_ExceptionMatches(PyExc_ValueError)) { +PyErr_Clear(); +return value_error_int(fmt); +} +return -1; +} +/* Accept integer objects or objects with an __index__() method. */ +static long +pylong_as_ld(PyObject *item) +{ +PyObject *tmp; +long ld; +tmp = _PyNumber_Index(item); +if (tmp == NULL) +return -1; +ld = PyLong_AsLong(tmp); +Py_DECREF(tmp); +return ld; +} +static unsigned long +pylong_as_lu(PyObject *item) +{ +PyObject *tmp; +unsigned long lu; +tmp = _PyNumber_Index(item); +if (tmp == NULL) +return (unsigned long)-1; +lu = PyLong_AsUnsignedLong(tmp); +Py_DECREF(tmp); +return lu; +} +static long long +pylong_as_lld(PyObject *item) +{ +PyObject *tmp; +long long lld; +tmp = _PyNumber_Index(item); +if (tmp == NULL) +return -1; +lld = PyLong_AsLongLong(tmp); +Py_DECREF(tmp); +return lld; +} +static unsigned long long +pylong_as_llu(PyObject *item) +{ +PyObject *tmp; +unsigned long long llu; +tmp = _PyNumber_Index(item); +if (tmp == NULL) +return (unsigned long long)-1; +llu = PyLong_AsUnsignedLongLong(tmp); +Py_DECREF(tmp); +return llu; +} +static Py_ssize_t +pylong_as_zd(PyObject *item) +{ +PyObject *tmp; +Py_ssize_t zd; +tmp = _PyNumber_Index(item); +if (tmp == NULL) +return -1; +zd = PyLong_AsSsize_t(tmp); +Py_DECREF(tmp); +return zd; +} +static size_t +pylong_as_zu(PyObject *item) +{ +PyObject *tmp; +size_t zu; +tmp = _PyNumber_Index(item); +if (tmp == NULL) +return (size_t)-1; +zu = PyLong_AsSize_t(tmp); +Py_DECREF(tmp); +return zu; +} +/* Timings with the ndarray from _testbuffer.c indicate that using the +struct module is around 15x slower than the two functions below. */ +#define UNPACK_SINGLE(dest, ptr, type) \ +do { \ +type x; \ +memcpy((char *)&x, ptr, sizeof x); \ +dest = x; \ +} while (0) +/* Unpack a single item. 'fmt' can be any native format character in struct +module syntax. This function is very sensitive to small changes. With this +layout gcc automatically generates a fast jump table. */ +static inline PyObject * +unpack_single(PyMemoryViewObject *self, const char *ptr, const char *fmt) +{ +unsigned long long llu; +unsigned long lu; +size_t zu; +long long lld; +long ld; +Py_ssize_t zd; +double d; +unsigned char uc; +void *p; +CHECK_RELEASED_AGAIN(self); +#if PY_LITTLE_ENDIAN +int endian = 1; +#else +int endian = 0; +#endif +switch (fmt[0]) { +/* signed integers and fast path for 'B' */ +case 'B': uc = *((const unsigned char *)ptr); goto convert_uc; +case 'b': ld = *((const signed char *)ptr); goto convert_ld; +case 'h': UNPACK_SINGLE(ld, ptr, short); goto convert_ld; +case 'i': UNPACK_SINGLE(ld, ptr, int); goto convert_ld; +case 'l': UNPACK_SINGLE(ld, ptr, long); goto convert_ld; +/* boolean */ +case '?': UNPACK_SINGLE(ld, ptr, _Bool); goto convert_bool; +/* unsigned integers */ +case 'H': UNPACK_SINGLE(lu, ptr, unsigned short); goto convert_lu; +case 'I': UNPACK_SINGLE(lu, ptr, unsigned int); goto convert_lu; +case 'L': UNPACK_SINGLE(lu, ptr, unsigned long); goto convert_lu; +/* native 64-bit */ +case 'q': UNPACK_SINGLE(lld, ptr, long long); goto convert_lld; +case 'Q': UNPACK_SINGLE(llu, ptr, unsigned long long); goto convert_llu; +/* ssize_t and size_t */ +case 'n': UNPACK_SINGLE(zd, ptr, Py_ssize_t); goto convert_zd; +case 'N': UNPACK_SINGLE(zu, ptr, size_t); goto convert_zu; +/* floats */ +case 'f': UNPACK_SINGLE(d, ptr, float); goto convert_double; +case 'd': UNPACK_SINGLE(d, ptr, double); goto convert_double; +case 'e': d = PyFloat_Unpack2(ptr, endian); goto convert_double; +/* bytes object */ +case 'c': goto convert_bytes; +/* pointer */ +case 'P': UNPACK_SINGLE(p, ptr, void *); goto convert_pointer; +/* default */ +default: goto err_format; +} +convert_uc: +/* PyLong_FromUnsignedLong() is slower */ +return PyLong_FromLong(uc); +convert_ld: +return PyLong_FromLong(ld); +convert_lu: +return PyLong_FromUnsignedLong(lu); +convert_lld: +return PyLong_FromLongLong(lld); +convert_llu: +return PyLong_FromUnsignedLongLong(llu); +convert_zd: +return PyLong_FromSsize_t(zd); +convert_zu: +return PyLong_FromSize_t(zu); +convert_double: +return PyFloat_FromDouble(d); +convert_bool: +return PyBool_FromLong(ld); +convert_bytes: +return PyBytes_FromStringAndSize(ptr, 1); +convert_pointer: +return PyLong_FromVoidPtr(p); +err_format: +PyErr_Format(PyExc_NotImplementedError, +"memoryview: format %s not supported", fmt); +return NULL; +} +#define PACK_SINGLE(ptr, src, type) \ +do { \ +type x; \ +x = (type)src; \ +memcpy(ptr, (char *)&x, sizeof x); \ +} while (0) +/* Pack a single item. 'fmt' can be any native format character in +struct module syntax. */ +static int +pack_single(PyMemoryViewObject *self, char *ptr, PyObject *item, const char *fmt) +{ +unsigned long long llu; +unsigned long lu; +size_t zu; +long long lld; +long ld; +Py_ssize_t zd; +double d; +void *p; +#if PY_LITTLE_ENDIAN +int endian = 1; +#else +int endian = 0; +#endif +switch (fmt[0]) { +/* signed integers */ +case 'b': case 'h': case 'i': case 'l': +ld = pylong_as_ld(item); +if (ld == -1 && PyErr_Occurred()) +goto err_occurred; +CHECK_RELEASED_INT_AGAIN(self); +switch (fmt[0]) { +case 'b': +if (ld < SCHAR_MIN || ld > SCHAR_MAX) goto err_range; +*((signed char *)ptr) = (signed char)ld; break; +case 'h': +if (ld < SHRT_MIN || ld > SHRT_MAX) goto err_range; +PACK_SINGLE(ptr, ld, short); break; +case 'i': +if (ld < INT_MIN || ld > INT_MAX) goto err_range; +PACK_SINGLE(ptr, ld, int); break; +default: /* 'l' */ +PACK_SINGLE(ptr, ld, long); break; +} +break; +/* unsigned integers */ +case 'B': case 'H': case 'I': case 'L': +lu = pylong_as_lu(item); +if (lu == (unsigned long)-1 && PyErr_Occurred()) +goto err_occurred; +CHECK_RELEASED_INT_AGAIN(self); +switch (fmt[0]) { +case 'B': +if (lu > UCHAR_MAX) goto err_range; +*((unsigned char *)ptr) = (unsigned char)lu; break; +case 'H': +if (lu > USHRT_MAX) goto err_range; +PACK_SINGLE(ptr, lu, unsigned short); break; +case 'I': +if (lu > UINT_MAX) goto err_range; +PACK_SINGLE(ptr, lu, unsigned int); break; +default: /* 'L' */ +PACK_SINGLE(ptr, lu, unsigned long); break; +} +break; +/* native 64-bit */ +case 'q': +lld = pylong_as_lld(item); +if (lld == -1 && PyErr_Occurred()) +goto err_occurred; +CHECK_RELEASED_INT_AGAIN(self); +PACK_SINGLE(ptr, lld, long long); +break; +case 'Q': +llu = pylong_as_llu(item); +if (llu == (unsigned long long)-1 && PyErr_Occurred()) +goto err_occurred; +CHECK_RELEASED_INT_AGAIN(self); +PACK_SINGLE(ptr, llu, unsigned long long); +break; +/* ssize_t and size_t */ +case 'n': +zd = pylong_as_zd(item); +if (zd == -1 && PyErr_Occurred()) +goto err_occurred; +CHECK_RELEASED_INT_AGAIN(self); +PACK_SINGLE(ptr, zd, Py_ssize_t); +break; +case 'N': +zu = pylong_as_zu(item); +if (zu == (size_t)-1 && PyErr_Occurred()) +goto err_occurred; +CHECK_RELEASED_INT_AGAIN(self); +PACK_SINGLE(ptr, zu, size_t); +break; +/* floats */ +case 'f': case 'd': case 'e': +d = PyFloat_AsDouble(item); +if (d == -1.0 && PyErr_Occurred()) +goto err_occurred; +CHECK_RELEASED_INT_AGAIN(self); +if (fmt[0] == 'f') { +PACK_SINGLE(ptr, d, float); +} +else if (fmt[0] == 'd') { +PACK_SINGLE(ptr, d, double); +} +else { +if (PyFloat_Pack2(d, ptr, endian) < 0) { +goto err_occurred; +} +} +break; +/* bool */ +case '?': +ld = PyObject_IsTrue(item); +if (ld < 0) +return -1; /* preserve original error */ +CHECK_RELEASED_INT_AGAIN(self); +PACK_SINGLE(ptr, ld, _Bool); +break; +/* bytes object */ +case 'c': +if (!PyBytes_Check(item)) +return type_error_int(fmt); +if (PyBytes_GET_SIZE(item) != 1) +return value_error_int(fmt); +*ptr = PyBytes_AS_STRING(item)[0]; +break; +/* pointer */ +case 'P': +p = PyLong_AsVoidPtr(item); +if (p == NULL && PyErr_Occurred()) +goto err_occurred; +CHECK_RELEASED_INT_AGAIN(self); +PACK_SINGLE(ptr, p, void *); +break; +/* default */ +default: goto err_format; +} +return 0; +err_occurred: +return fix_error_int(fmt); +err_range: +return value_error_int(fmt); +err_format: +PyErr_Format(PyExc_NotImplementedError, +"memoryview: format %s not supported", fmt); +return -1; +} +/****************************************************************************/ +/* unpack using the struct module */ +/****************************************************************************/ +/* For reasonable performance it is necessary to cache all objects required +for unpacking. An unpacker can handle the format passed to unpack_from(). +Invariant: All pointer fields of the struct should either be NULL or valid +pointers. */ +struct unpacker { +PyObject *unpack_from; /* Struct.unpack_from(format) */ +PyObject *mview; /* cached memoryview */ +char *item; /* buffer for mview */ +Py_ssize_t itemsize; /* len(item) */ +}; +static struct unpacker * +unpacker_new(void) +{ +struct unpacker *x = PyMem_Malloc(sizeof *x); +if (x == NULL) { +PyErr_NoMemory(); +return NULL; +} +x->unpack_from = NULL; +x->mview = NULL; +x->item = NULL; +x->itemsize = 0; +return x; +} +static void +unpacker_free(struct unpacker *x) +{ +if (x) { +Py_XDECREF(x->unpack_from); +Py_XDECREF(x->mview); +PyMem_Free(x->item); +PyMem_Free(x); +} +} +/* Return a new unpacker for the given format. */ +static struct unpacker * +struct_get_unpacker(const char *fmt, Py_ssize_t itemsize) +{ +PyObject *Struct = NULL; /* XXX cache it in globals? */ +PyObject *structobj = NULL; +PyObject *format = NULL; +struct unpacker *x = NULL; +Struct = PyImport_ImportModuleAttrString("struct", "Struct"); +if (Struct == NULL) +return NULL; +x = unpacker_new(); +if (x == NULL) +goto error; +format = PyBytes_FromString(fmt); +if (format == NULL) +goto error; +structobj = PyObject_CallOneArg(Struct, format); +if (structobj == NULL) +goto error; +x->unpack_from = PyObject_GetAttrString(structobj, "unpack_from"); +if (x->unpack_from == NULL) +goto error; +x->item = PyMem_Malloc(itemsize); +if (x->item == NULL) { +PyErr_NoMemory(); +goto error; +} +x->itemsize = itemsize; +x->mview = PyMemoryView_FromMemory(x->item, itemsize, PyBUF_WRITE); +if (x->mview == NULL) +goto error; +out: +Py_XDECREF(Struct); +Py_XDECREF(format); +Py_XDECREF(structobj); +return x; +error: +unpacker_free(x); +x = NULL; +goto out; +} +/* unpack a single item */ +static PyObject * +struct_unpack_single(const char *ptr, struct unpacker *x) +{ +PyObject *v; +memcpy(x->item, ptr, x->itemsize); +v = PyObject_CallOneArg(x->unpack_from, x->mview); +if (v == NULL) +return NULL; +if (PyTuple_GET_SIZE(v) == 1) { +PyObject *res = Py_NewRef(PyTuple_GET_ITEM(v, 0)); +Py_DECREF(v); +return res; +} +return v; +} +/****************************************************************************/ +/* Representations */ +/****************************************************************************/ +/* allow explicit form of native format */ +static inline const char * +adjust_fmt(const Py_buffer *view) +{ +const char *fmt; +fmt = (view->format[0] == '@') ? view->format+1 : view->format; +if (fmt[0] && fmt[1] == '\0') +return fmt; +PyErr_Format(PyExc_NotImplementedError, +"memoryview: unsupported format %s", view->format); +return NULL; +} +/* Base case for multi-dimensional unpacking. Assumption: ndim == 1. */ +static PyObject * +tolist_base(PyMemoryViewObject *self, const char *ptr, const Py_ssize_t *shape, +const Py_ssize_t *strides, const Py_ssize_t *suboffsets, +const char *fmt) +{ +PyObject *lst, *item; +Py_ssize_t i; +lst = PyList_New(shape[0]); +if (lst == NULL) +return NULL; +for (i = 0; i < shape[0]; ptr+=strides[0], i++) { +const char *xptr = ADJUST_PTR(ptr, suboffsets, 0); +item = unpack_single(self, xptr, fmt); +if (item == NULL) { +Py_DECREF(lst); +return NULL; +} +PyList_SET_ITEM(lst, i, item); +} +return lst; +} +/* Unpack a multi-dimensional array into a nested list. +Assumption: ndim >= 1. */ +static PyObject * +tolist_rec(PyMemoryViewObject *self, const char *ptr, Py_ssize_t ndim, const Py_ssize_t *shape, +const Py_ssize_t *strides, const Py_ssize_t *suboffsets, +const char *fmt) +{ +PyObject *lst, *item; +Py_ssize_t i; +assert(ndim >= 1); +assert(shape != NULL); +assert(strides != NULL); +if (ndim == 1) +return tolist_base(self, ptr, shape, strides, suboffsets, fmt); +lst = PyList_New(shape[0]); +if (lst == NULL) +return NULL; +for (i = 0; i < shape[0]; ptr+=strides[0], i++) { +const char *xptr = ADJUST_PTR(ptr, suboffsets, 0); +item = tolist_rec(self, xptr, ndim-1, shape+1, +strides+1, suboffsets ? suboffsets+1 : NULL, +fmt); +if (item == NULL) { +Py_DECREF(lst); +return NULL; +} +PyList_SET_ITEM(lst, i, item); +} +return lst; +} +/* Return a list representation of the memoryview. Currently only buffers +with native format strings are supported. */ +/*[clinic input] +memoryview.tolist +Return the data in the buffer as a list of elements. +[clinic start generated code]*/ +static PyObject * +memoryview_tolist_impl(PyMemoryViewObject *self) +/*[clinic end generated code: output=a6cda89214fd5a1b input=21e7d0c1860b211a]*/ +{ +const Py_buffer *view = &self->view; +const char *fmt; +CHECK_RELEASED(self); +fmt = adjust_fmt(view); +if (fmt == NULL) +return NULL; +if (view->ndim == 0) { +return unpack_single(self, view->buf, fmt); +} +else if (view->ndim == 1) { +return tolist_base(self, view->buf, view->shape, +view->strides, view->suboffsets, +fmt); +} +else { +return tolist_rec(self, view->buf, view->ndim, view->shape, +view->strides, view->suboffsets, +fmt); +} +} +/*[clinic input] +@permit_long_docstring_body +memoryview.tobytes +order: str(accept={str, NoneType}, c_default="NULL") = 'C' +Return the data in the buffer as a byte string. +Order can be {'C', 'F', 'A'}. When order is 'C' or 'F', the data of the +original array is converted to C or Fortran order. For contiguous views, +'A' returns an exact copy of the physical memory. In particular, in-memory +Fortran order is preserved. For non-contiguous views, the data is converted +to C first. order=None is the same as order='C'. +[clinic start generated code]*/ +static PyObject * +memoryview_tobytes_impl(PyMemoryViewObject *self, const char *order) +/*[clinic end generated code: output=1288b62560a32a23 input=23c9faf372cfdbcc]*/ +{ +Py_buffer *src = VIEW_ADDR(self); +char ord = 'C'; +CHECK_RELEASED(self); +if (order) { +if (strcmp(order, "F") == 0) { +ord = 'F'; +} +else if (strcmp(order, "A") == 0) { +ord = 'A'; +} +else if (strcmp(order, "C") != 0) { +PyErr_SetString(PyExc_ValueError, +"order must be 'C', 'F' or 'A'"); +return NULL; +} +} +PyBytesWriter *writer = PyBytesWriter_Create(src->len); +if (writer == NULL) { +return NULL; +} +if (PyBuffer_ToContiguous(PyBytesWriter_GetData(writer), +src, src->len, ord) < 0) { +PyBytesWriter_Discard(writer); +return NULL; +} +return PyBytesWriter_Finish(writer); +} +/*[clinic input] +memoryview.hex +sep: object = NULL +An optional single character or byte to separate hex bytes. +bytes_per_sep: int = 1 +How many bytes between separators. Positive values count from the +right, negative values count from the left. +Return the data in the buffer as a str of hexadecimal numbers. +Example: +>>> value = memoryview(b'\xb9\x01\xef') +>>> value.hex() +'b901ef' +>>> value.hex(':') +'b9:01:ef' +>>> value.hex(':', 2) +'b9:01ef' +>>> value.hex(':', -2) +'b901:ef' +[clinic start generated code]*/ +static PyObject * +memoryview_hex_impl(PyMemoryViewObject *self, PyObject *sep, +int bytes_per_sep) +/*[clinic end generated code: output=430ca760f94f3ca7 input=539f6a3a5fb56946]*/ +{ +Py_buffer *src = VIEW_ADDR(self); +CHECK_RELEASED(self); +if (MV_C_CONTIGUOUS(self->flags)) { +// Prevent 'self' from being freed if computing len(sep) mutates 'self' +// in _Py_strhex_with_sep(). +// See: https://github.com/python/cpython/issues/143195. +self->exports++; +PyObject *ret = _Py_strhex_with_sep(src->buf, src->len, sep, bytes_per_sep); +self->exports--; +return ret; +} +PyBytesWriter *writer = PyBytesWriter_Create(src->len); +if (writer == NULL) { +return NULL; +} +if (PyBuffer_ToContiguous(PyBytesWriter_GetData(writer), +src, src->len, 'C') < 0) { +PyBytesWriter_Discard(writer); +return NULL; +} +PyObject *ret = _Py_strhex_with_sep( +PyBytesWriter_GetData(writer), +PyBytesWriter_GetSize(writer), +sep, bytes_per_sep); +PyBytesWriter_Discard(writer); +return ret; +} +static PyObject * +memory_repr(PyObject *_self) +{ +PyMemoryViewObject *self = (PyMemoryViewObject *)_self; +if (self->flags & _Py_MEMORYVIEW_RELEASED) +return PyUnicode_FromFormat("", self); +else +return PyUnicode_FromFormat("", self); +} +/**************************************************************************/ +/* Indexing and slicing */ +/**************************************************************************/ +static char * +lookup_dimension(const Py_buffer *view, char *ptr, int dim, Py_ssize_t index) +{ +Py_ssize_t nitems; /* items in the given dimension */ +assert(view->shape); +assert(view->strides); +nitems = view->shape[dim]; +if (index < 0) { +index += nitems; +} +if (index < 0 || index >= nitems) { +PyErr_Format(PyExc_IndexError, +"index out of bounds on dimension %d", dim + 1); +return NULL; +} +ptr += view->strides[dim] * index; +ptr = ADJUST_PTR(ptr, view->suboffsets, dim); +return ptr; +} +/* Get the pointer to the item at index. */ +static char * +ptr_from_index(const Py_buffer *view, Py_ssize_t index) +{ +char *ptr = (char *)view->buf; +return lookup_dimension(view, ptr, 0, index); +} +/* Get the pointer to the item at tuple. */ +static char * +ptr_from_tuple(const Py_buffer *view, PyObject *tup) +{ +char *ptr = (char *)view->buf; +Py_ssize_t dim, nindices = PyTuple_GET_SIZE(tup); +if (nindices > view->ndim) { +PyErr_Format(PyExc_TypeError, +"cannot index %zd-dimension view with %zd-element tuple", +view->ndim, nindices); +return NULL; +} +for (dim = 0; dim < nindices; dim++) { +Py_ssize_t index; +index = PyNumber_AsSsize_t(PyTuple_GET_ITEM(tup, dim), +PyExc_IndexError); +if (index == -1 && PyErr_Occurred()) +return NULL; +ptr = lookup_dimension(view, ptr, (int)dim, index); +if (ptr == NULL) +return NULL; +} +return ptr; +} +/* Return the item at index. In a one-dimensional view, this is an object +with the type specified by view->format. Otherwise, the item is a sub-view. +The function is used in memory_subscript() and memory_as_sequence. */ +static PyObject * +memory_item(PyObject *_self, Py_ssize_t index) +{ +PyMemoryViewObject *self = (PyMemoryViewObject *)_self; +Py_buffer *view = &(self->view); +const char *fmt; +CHECK_RELEASED(self); +fmt = adjust_fmt(view); +if (fmt == NULL) +return NULL; +if (view->ndim == 0) { +PyErr_SetString(PyExc_TypeError, "invalid indexing of 0-dim memory"); +return NULL; +} +if (view->ndim == 1) { +char *ptr = ptr_from_index(view, index); +if (ptr == NULL) +return NULL; +return unpack_single(self, ptr, fmt); +} +PyErr_SetString(PyExc_NotImplementedError, +"multi-dimensional sub-views are not implemented"); +return NULL; +} +/* Return the item at position *key* (a tuple of indices). */ +static PyObject * +memory_item_multi(PyMemoryViewObject *self, PyObject *tup) +{ +Py_buffer *view = &(self->view); +const char *fmt; +Py_ssize_t nindices = PyTuple_GET_SIZE(tup); +char *ptr; +CHECK_RELEASED(self); +fmt = adjust_fmt(view); +if (fmt == NULL) +return NULL; +if (nindices < view->ndim) { +PyErr_SetString(PyExc_NotImplementedError, +"sub-views are not implemented"); +return NULL; +} +ptr = ptr_from_tuple(view, tup); +if (ptr == NULL) +return NULL; +return unpack_single(self, ptr, fmt); +} +static inline int +init_slice(Py_buffer *base, PyObject *key, int dim) +{ +Py_ssize_t start, stop, step, slicelength; +if (PySlice_Unpack(key, &start, &stop, &step) < 0) { +return -1; +} +slicelength = PySlice_AdjustIndices(base->shape[dim], &start, &stop, step); +if (base->suboffsets == NULL || dim == 0) { +adjust_buf: +base->buf = (char *)base->buf + base->strides[dim] * start; +} +else { +Py_ssize_t n = dim-1; +while (n >= 0 && base->suboffsets[n] < 0) +n--; +if (n < 0) +goto adjust_buf; /* all suboffsets are negative */ +base->suboffsets[n] = base->suboffsets[n] + base->strides[dim] * start; +} +base->shape[dim] = slicelength; +base->strides[dim] = base->strides[dim] * step; +return 0; +} +static int +is_multislice(PyObject *key) +{ +Py_ssize_t size, i; +if (!PyTuple_Check(key)) +return 0; +size = PyTuple_GET_SIZE(key); +if (size == 0) +return 0; +for (i = 0; i < size; i++) { +PyObject *x = PyTuple_GET_ITEM(key, i); +if (!PySlice_Check(x)) +return 0; +} +return 1; +} +static Py_ssize_t +is_multiindex(PyObject *key) +{ +Py_ssize_t size, i; +if (!PyTuple_Check(key)) +return 0; +size = PyTuple_GET_SIZE(key); +for (i = 0; i < size; i++) { +PyObject *x = PyTuple_GET_ITEM(key, i); +if (!_PyIndex_Check(x)) { +return 0; +} +} +return 1; +} +/* mv[obj] returns an object holding the data for one element if obj +fully indexes the memoryview or another memoryview object if it +does not. +0-d memoryview objects can be referenced using mv[...] or mv[()] +but not with anything else. */ +static PyObject * +memory_subscript(PyObject *_self, PyObject *key) +{ +PyMemoryViewObject *self = (PyMemoryViewObject *)_self; +Py_buffer *view; +view = &(self->view); +CHECK_RELEASED(self); +if (view->ndim == 0) { +if (PyTuple_Check(key) && PyTuple_GET_SIZE(key) == 0) { +const char *fmt = adjust_fmt(view); +if (fmt == NULL) +return NULL; +return unpack_single(self, view->buf, fmt); +} +else if (key == Py_Ellipsis) { +return Py_NewRef(self); +} +else { +PyErr_SetString(PyExc_TypeError, +"invalid indexing of 0-dim memory"); +return NULL; +} +} +if (_PyIndex_Check(key)) { +Py_ssize_t index; +index = PyNumber_AsSsize_t(key, PyExc_IndexError); +if (index == -1 && PyErr_Occurred()) +return NULL; +return memory_item((PyObject *)self, index); +} +else if (PySlice_Check(key)) { +CHECK_RESTRICTED(self); +PyMemoryViewObject *sliced; +sliced = (PyMemoryViewObject *)mbuf_add_view(self->mbuf, view); +if (sliced == NULL) +return NULL; +if (init_slice(&sliced->view, key, 0) < 0) { +Py_DECREF(sliced); +return NULL; +} +init_len(&sliced->view); +init_flags(sliced); +return (PyObject *)sliced; +} +else if (is_multiindex(key)) { +return memory_item_multi(self, key); +} +else if (is_multislice(key)) { +PyErr_SetString(PyExc_NotImplementedError, +"multi-dimensional slicing is not implemented"); +return NULL; +} +PyErr_SetString(PyExc_TypeError, "memoryview: invalid slice key"); +return NULL; +} +static int +memory_ass_sub(PyObject *_self, PyObject *key, PyObject *value) +{ +PyMemoryViewObject *self = (PyMemoryViewObject *)_self; +Py_buffer *view = &(self->view); +Py_buffer src; +const char *fmt; +char *ptr; +CHECK_RELEASED_INT(self); +fmt = adjust_fmt(view); +if (fmt == NULL) +return -1; +if (view->readonly) { +PyErr_SetString(PyExc_TypeError, "cannot modify read-only memory"); +return -1; +} +if (value == NULL) { +PyErr_SetString(PyExc_TypeError, "cannot delete memory"); +return -1; +} +if (view->ndim == 0) { +if (key == Py_Ellipsis || +(PyTuple_Check(key) && PyTuple_GET_SIZE(key)==0)) { +ptr = (char *)view->buf; +return pack_single(self, ptr, value, fmt); +} +else { +PyErr_SetString(PyExc_TypeError, +"invalid indexing of 0-dim memory"); +return -1; +} +} +if (_PyIndex_Check(key)) { +Py_ssize_t index; +if (1 < view->ndim) { +PyErr_SetString(PyExc_NotImplementedError, +"sub-views are not implemented"); +return -1; +} +index = PyNumber_AsSsize_t(key, PyExc_IndexError); +if (index == -1 && PyErr_Occurred()) +return -1; +ptr = ptr_from_index(view, index); +if (ptr == NULL) +return -1; +return pack_single(self, ptr, value, fmt); +} +/* one-dimensional: fast path */ +if (PySlice_Check(key) && view->ndim == 1) { +Py_buffer dest; /* sliced view */ +Py_ssize_t arrays[3]; +int ret = -1; +/* rvalue must be an exporter */ +if (PyObject_GetBuffer(value, &src, PyBUF_FULL_RO) < 0) +return ret; +dest = *view; +dest.shape = &arrays[0]; dest.shape[0] = view->shape[0]; +dest.strides = &arrays[1]; dest.strides[0] = view->strides[0]; +if (view->suboffsets) { +dest.suboffsets = &arrays[2]; dest.suboffsets[0] = view->suboffsets[0]; +} +if (init_slice(&dest, key, 0) < 0) +goto end_block; +dest.len = dest.shape[0] * dest.itemsize; +ret = copy_single(self, &dest, &src); +end_block: +PyBuffer_Release(&src); +return ret; +} +if (is_multiindex(key)) { +char *ptr; +if (PyTuple_GET_SIZE(key) < view->ndim) { +PyErr_SetString(PyExc_NotImplementedError, +"sub-views are not implemented"); +return -1; +} +ptr = ptr_from_tuple(view, key); +if (ptr == NULL) +return -1; +return pack_single(self, ptr, value, fmt); +} +if (PySlice_Check(key) || is_multislice(key)) { +/* Call memory_subscript() to produce a sliced lvalue, then copy +rvalue into lvalue. This is already implemented in _testbuffer.c. */ +PyErr_SetString(PyExc_NotImplementedError, +"memoryview slice assignments are currently restricted " +"to ndim = 1"); +return -1; +} +PyErr_SetString(PyExc_TypeError, "memoryview: invalid slice key"); +return -1; +} +static Py_ssize_t +memory_length(PyObject *_self) +{ +PyMemoryViewObject *self = (PyMemoryViewObject *)_self; +CHECK_RELEASED_INT(self); +if (self->view.ndim == 0) { +PyErr_SetString(PyExc_TypeError, "0-dim memory has no length"); +return -1; +} +return self->view.shape[0]; +} +/* As mapping */ +static PyMappingMethods memory_as_mapping = { +memory_length, /* mp_length */ +memory_subscript, /* mp_subscript */ +memory_ass_sub, /* mp_ass_subscript */ +}; +/* As sequence */ +static PySequenceMethods memory_as_sequence = { +memory_length, /* sq_length */ +0, /* sq_concat */ +0, /* sq_repeat */ +memory_item, /* sq_item */ +}; +/****************************************************************************/ +/* Counting */ +/****************************************************************************/ +/*[clinic input] +memoryview.count +value: object +/ +Count the number of occurrences of a value. +[clinic start generated code]*/ +static PyObject * +memoryview_count_impl(PyMemoryViewObject *self, PyObject *value) +/*[clinic end generated code: output=a15cb19311985063 input=e3036ce1ed7d1823]*/ +{ +PyObject *iter = PyObject_GetIter(_PyObject_CAST(self)); +if (iter == NULL) { +return NULL; +} +Py_ssize_t count = 0; +PyObject *item = NULL; +while (PyIter_NextItem(iter, &item)) { +if (item == NULL) { +Py_DECREF(iter); +return NULL; +} +if (item == value) { +Py_DECREF(item); +count++; // no overflow since count <= len(mv) <= PY_SSIZE_T_MAX +continue; +} +int contained = PyObject_RichCompareBool(item, value, Py_EQ); +Py_DECREF(item); +if (contained > 0) { // more likely than 'contained < 0' +count++; // no overflow since count <= len(mv) <= PY_SSIZE_T_MAX +} +else if (contained < 0) { +Py_DECREF(iter); +return NULL; +} +} +Py_DECREF(iter); +return PyLong_FromSsize_t(count); +} +/**************************************************************************/ +/* Lookup */ +/**************************************************************************/ +/*[clinic input] +memoryview.index +value: object +start: slice_index(accept={int}) = 0 +stop: slice_index(accept={int}, c_default="PY_SSIZE_T_MAX") = sys.maxsize +/ +Return the index of the first occurrence of a value. +Raises ValueError if the value is not present. +[clinic start generated code]*/ +static PyObject * +memoryview_index_impl(PyMemoryViewObject *self, PyObject *value, +Py_ssize_t start, Py_ssize_t stop) +/*[clinic end generated code: output=e0185e3819e549df input=0697a0165bf90b5a]*/ +{ +const Py_buffer *view = &self->view; +CHECK_RELEASED(self); +if (view->ndim == 0) { +PyErr_SetString(PyExc_TypeError, "invalid lookup on 0-dim memory"); +return NULL; +} +if (view->ndim == 1) { +Py_ssize_t n = view->shape[0]; +if (start < 0) { +start = Py_MAX(start + n, 0); +} +if (stop < 0) { +stop = Py_MAX(stop + n, 0); +} +stop = Py_MIN(stop, n); +assert(stop >= 0); +assert(stop <= n); +start = Py_MIN(start, stop); +assert(0 <= start); +assert(start <= stop); +PyObject *obj = _PyObject_CAST(self); +for (Py_ssize_t index = start; index < stop; index++) { +// Note: while memoryviews can be mutated during iterations +// when calling the == operator, their shape cannot. As such, +// it is safe to assume that the index remains valid for the +// entire loop. +assert(index < n); +PyObject *item = memory_item(obj, index); +if (item == NULL) { +return NULL; +} +if (item == value) { +Py_DECREF(item); +return PyLong_FromSsize_t(index); +} +int contained = PyObject_RichCompareBool(item, value, Py_EQ); +Py_DECREF(item); +if (contained > 0) { // more likely than 'contained < 0' +return PyLong_FromSsize_t(index); +} +else if (contained < 0) { +return NULL; +} +} +PyErr_SetString(PyExc_ValueError, "memoryview.index(x): x not found"); +return NULL; +} +PyErr_SetString(PyExc_NotImplementedError, +"multi-dimensional lookup is not implemented"); +return NULL; +} +/**************************************************************************/ +/* Comparisons */ +/**************************************************************************/ +#define MV_COMPARE_EX -1 /* exception */ +#define MV_COMPARE_NOT_IMPL -2 /* not implemented */ +/* Translate a StructError to "not equal". Preserve other exceptions. */ +static int +fix_struct_error_int(void) +{ +assert(PyErr_Occurred()); +/* XXX Cannot get at StructError directly? */ +if (PyErr_ExceptionMatches(PyExc_ImportError) || +PyErr_ExceptionMatches(PyExc_MemoryError)) { +return MV_COMPARE_EX; +} +/* StructError: invalid or unknown format -> not equal */ +PyErr_Clear(); +return 0; +} +/* Unpack and compare single items of p and q using the struct module. */ +static int +struct_unpack_cmp(const char *p, const char *q, +struct unpacker *unpack_p, struct unpacker *unpack_q) +{ +PyObject *v, *w; +int ret; +/* At this point any exception from the struct module should not be +StructError, since both formats have been accepted already. */ +v = struct_unpack_single(p, unpack_p); +if (v == NULL) +return MV_COMPARE_EX; +w = struct_unpack_single(q, unpack_q); +if (w == NULL) { +Py_DECREF(v); +return MV_COMPARE_EX; +} +/* MV_COMPARE_EX == -1: exceptions are preserved */ +ret = PyObject_RichCompareBool(v, w, Py_EQ); +Py_DECREF(v); +Py_DECREF(w); +return ret; +} +/* Unpack and compare single items of p and q. If both p and q have the same +single element native format, the comparison uses a fast path (gcc creates +a jump table and converts memcpy into simple assignments on x86/x64). +Otherwise, the comparison is delegated to the struct module, which is +30-60x slower. */ +#define CMP_SINGLE(p, q, type) \ +do { \ +type x; \ +type y; \ +memcpy((char *)&x, p, sizeof x); \ +memcpy((char *)&y, q, sizeof y); \ +equal = (x == y); \ +} while (0) +static inline int +unpack_cmp(const char *p, const char *q, char fmt, +struct unpacker *unpack_p, struct unpacker *unpack_q) +{ +int equal; +switch (fmt) { +/* signed integers and fast path for 'B' */ +case 'B': return *((const unsigned char *)p) == *((const unsigned char *)q); +case 'b': return *((const signed char *)p) == *((const signed char *)q); +case 'h': CMP_SINGLE(p, q, short); return equal; +case 'i': CMP_SINGLE(p, q, int); return equal; +case 'l': CMP_SINGLE(p, q, long); return equal; +/* boolean */ +case '?': CMP_SINGLE(p, q, _Bool); return equal; +/* unsigned integers */ +case 'H': CMP_SINGLE(p, q, unsigned short); return equal; +case 'I': CMP_SINGLE(p, q, unsigned int); return equal; +case 'L': CMP_SINGLE(p, q, unsigned long); return equal; +/* native 64-bit */ +case 'q': CMP_SINGLE(p, q, long long); return equal; +case 'Q': CMP_SINGLE(p, q, unsigned long long); return equal; +/* ssize_t and size_t */ +case 'n': CMP_SINGLE(p, q, Py_ssize_t); return equal; +case 'N': CMP_SINGLE(p, q, size_t); return equal; +/* floats */ +/* XXX DBL_EPSILON? */ +case 'f': CMP_SINGLE(p, q, float); return equal; +case 'd': CMP_SINGLE(p, q, double); return equal; +case 'e': { +#if PY_LITTLE_ENDIAN +int endian = 1; +#else +int endian = 0; +#endif +/* Note: PyFloat_Unpack2 should never fail */ +double u = PyFloat_Unpack2(p, endian); +double v = PyFloat_Unpack2(q, endian); +return (u == v); +} +/* bytes object */ +case 'c': return *p == *q; +/* pointer */ +case 'P': CMP_SINGLE(p, q, void *); return equal; +/* use the struct module */ +case '_': +assert(unpack_p); +assert(unpack_q); +return struct_unpack_cmp(p, q, unpack_p, unpack_q); +} +/* NOT REACHED */ +PyErr_SetString(PyExc_RuntimeError, +"memoryview: internal error in richcompare"); +return MV_COMPARE_EX; +} +/* Base case for recursive array comparisons. Assumption: ndim == 1. */ +static int +cmp_base(const char *p, const char *q, const Py_ssize_t *shape, +const Py_ssize_t *pstrides, const Py_ssize_t *psuboffsets, +const Py_ssize_t *qstrides, const Py_ssize_t *qsuboffsets, +char fmt, struct unpacker *unpack_p, struct unpacker *unpack_q) +{ +Py_ssize_t i; +int equal; +for (i = 0; i < shape[0]; p+=pstrides[0], q+=qstrides[0], i++) { +const char *xp = ADJUST_PTR(p, psuboffsets, 0); +const char *xq = ADJUST_PTR(q, qsuboffsets, 0); +equal = unpack_cmp(xp, xq, fmt, unpack_p, unpack_q); +if (equal <= 0) +return equal; +} +return 1; +} +/* Recursively compare two multi-dimensional arrays that have the same +logical structure. Assumption: ndim >= 1. */ +static int +cmp_rec(const char *p, const char *q, +Py_ssize_t ndim, const Py_ssize_t *shape, +const Py_ssize_t *pstrides, const Py_ssize_t *psuboffsets, +const Py_ssize_t *qstrides, const Py_ssize_t *qsuboffsets, +char fmt, struct unpacker *unpack_p, struct unpacker *unpack_q) +{ +Py_ssize_t i; +int equal; +assert(ndim >= 1); +assert(shape != NULL); +assert(pstrides != NULL); +assert(qstrides != NULL); +if (ndim == 1) { +return cmp_base(p, q, shape, +pstrides, psuboffsets, +qstrides, qsuboffsets, +fmt, unpack_p, unpack_q); +} +for (i = 0; i < shape[0]; p+=pstrides[0], q+=qstrides[0], i++) { +const char *xp = ADJUST_PTR(p, psuboffsets, 0); +const char *xq = ADJUST_PTR(q, qsuboffsets, 0); +equal = cmp_rec(xp, xq, ndim-1, shape+1, +pstrides+1, psuboffsets ? psuboffsets+1 : NULL, +qstrides+1, qsuboffsets ? qsuboffsets+1 : NULL, +fmt, unpack_p, unpack_q); +if (equal <= 0) +return equal; +} +return 1; +} +static PyObject * +memory_richcompare(PyObject *v, PyObject *w, int op) +{ +PyObject *res; +Py_buffer wbuf, *vv; +Py_buffer *ww = NULL; +struct unpacker *unpack_v = NULL; +struct unpacker *unpack_w = NULL; +char vfmt, wfmt; +int equal = MV_COMPARE_NOT_IMPL; +if (op != Py_EQ && op != Py_NE) +goto result; /* Py_NotImplemented */ +assert(PyMemoryView_Check(v)); +if (BASE_INACCESSIBLE(v)) { +equal = (v == w); +goto result; +} +vv = VIEW_ADDR(v); +if (PyMemoryView_Check(w)) { +if (BASE_INACCESSIBLE(w)) { +equal = (v == w); +goto result; +} +ww = VIEW_ADDR(w); +} +else { +if (PyObject_GetBuffer(w, &wbuf, PyBUF_FULL_RO) < 0) { +PyErr_Clear(); +goto result; /* Py_NotImplemented */ +} +ww = &wbuf; +} +if (!equiv_shape(vv, ww)) { +PyErr_Clear(); +equal = 0; +goto result; +} +/* Use fast unpacking for identical primitive C type formats. */ +if (get_native_fmtchar(&vfmt, vv->format) < 0) +vfmt = '_'; +if (get_native_fmtchar(&wfmt, ww->format) < 0) +wfmt = '_'; +if (vfmt == '_' || wfmt == '_' || vfmt != wfmt) { +/* Use struct module unpacking. NOTE: Even for equal format strings, +memcmp() cannot be used for item comparison since it would give +incorrect results in the case of NaNs or uninitialized padding +bytes. */ +vfmt = '_'; +unpack_v = struct_get_unpacker(vv->format, vv->itemsize); +if (unpack_v == NULL) { +equal = fix_struct_error_int(); +goto result; +} +unpack_w = struct_get_unpacker(ww->format, ww->itemsize); +if (unpack_w == NULL) { +equal = fix_struct_error_int(); +goto result; +} +} +if (vv->ndim == 0) { +equal = unpack_cmp(vv->buf, ww->buf, +vfmt, unpack_v, unpack_w); +} +else if (vv->ndim == 1) { +equal = cmp_base(vv->buf, ww->buf, vv->shape, +vv->strides, vv->suboffsets, +ww->strides, ww->suboffsets, +vfmt, unpack_v, unpack_w); +} +else { +equal = cmp_rec(vv->buf, ww->buf, vv->ndim, vv->shape, +vv->strides, vv->suboffsets, +ww->strides, ww->suboffsets, +vfmt, unpack_v, unpack_w); +} +result: +if (equal < 0) { +if (equal == MV_COMPARE_NOT_IMPL) +res = Py_NotImplemented; +else /* exception */ +res = NULL; +} +else if ((equal && op == Py_EQ) || (!equal && op == Py_NE)) +res = Py_True; +else +res = Py_False; +if (ww == &wbuf) +PyBuffer_Release(ww); +unpacker_free(unpack_v); +unpacker_free(unpack_w); +return Py_XNewRef(res); +} +/**************************************************************************/ +/* Hash */ +/**************************************************************************/ +static Py_hash_t +memory_hash(PyObject *_self) +{ +PyMemoryViewObject *self = (PyMemoryViewObject *)_self; +if (self->hash == -1) { +Py_buffer *view = &self->view; +char *mem = view->buf; +Py_ssize_t ret; +char fmt; +CHECK_RELEASED_INT(self); +if (!view->readonly) { +PyErr_SetString(PyExc_ValueError, +"cannot hash writable memoryview object"); +return -1; +} +ret = get_native_fmtchar(&fmt, view->format); +if (ret < 0 || !IS_BYTE_FORMAT(fmt)) { +PyErr_SetString(PyExc_ValueError, +"memoryview: hashing is restricted to formats 'B', 'b' or 'c'"); +return -1; +} +if (view->obj != NULL) { +// Prevent 'self' from being freed when computing the item's hash. +// See https://github.com/python/cpython/issues/142664. +self->exports++; +Py_hash_t h = PyObject_Hash(view->obj); +self->exports--; +if (h == -1) { +/* Keep the original error message */ +return -1; +} +} +if (!MV_C_CONTIGUOUS(self->flags)) { +mem = PyMem_Malloc(view->len); +if (mem == NULL) { +PyErr_NoMemory(); +return -1; +} +if (buffer_to_contiguous(mem, view, 'C') < 0) { +PyMem_Free(mem); +return -1; +} +} +/* Can't fail */ +self->hash = Py_HashBuffer(mem, view->len); +if (mem != view->buf) +PyMem_Free(mem); +} +return self->hash; +} +/**************************************************************************/ +/* getters */ +/**************************************************************************/ +static PyObject * +_IntTupleFromSsizet(int len, Py_ssize_t *vals) +{ +int i; +PyObject *o; +PyObject *intTuple; +if (vals == NULL) +return PyTuple_New(0); +intTuple = PyTuple_New(len); +if (!intTuple) +return NULL; +for (i=0; iview; +CHECK_RELEASED(self); +if (view->obj == NULL) { +Py_RETURN_NONE; +} +return Py_NewRef(view->obj); +} +static PyObject * +memory_nbytes_get(PyObject *_self, void *Py_UNUSED(ignored)) +{ +PyMemoryViewObject *self = (PyMemoryViewObject *)_self; +CHECK_RELEASED(self); +return PyLong_FromSsize_t(self->view.len); +} +static PyObject * +memory_format_get(PyObject *_self, void *Py_UNUSED(ignored)) +{ +PyMemoryViewObject *self = (PyMemoryViewObject *)_self; +CHECK_RELEASED(self); +return PyUnicode_FromString(self->view.format); +} +static PyObject * +memory_itemsize_get(PyObject *_self, void *Py_UNUSED(ignored)) +{ +PyMemoryViewObject *self = (PyMemoryViewObject *)_self; +CHECK_RELEASED(self); +return PyLong_FromSsize_t(self->view.itemsize); +} +static PyObject * +memory_shape_get(PyObject *_self, void *Py_UNUSED(ignored)) +{ +PyMemoryViewObject *self = (PyMemoryViewObject *)_self; +CHECK_RELEASED(self); +return _IntTupleFromSsizet(self->view.ndim, self->view.shape); +} +static PyObject * +memory_strides_get(PyObject *_self, void *Py_UNUSED(ignored)) +{ +PyMemoryViewObject *self = (PyMemoryViewObject *)_self; +CHECK_RELEASED(self); +return _IntTupleFromSsizet(self->view.ndim, self->view.strides); +} +static PyObject * +memory_suboffsets_get(PyObject *_self, void *Py_UNUSED(ignored)) +{ +PyMemoryViewObject *self = (PyMemoryViewObject *)_self; +CHECK_RELEASED(self); +return _IntTupleFromSsizet(self->view.ndim, self->view.suboffsets); +} +static PyObject * +memory_readonly_get(PyObject *_self, void *Py_UNUSED(ignored)) +{ +PyMemoryViewObject *self = (PyMemoryViewObject *)_self; +CHECK_RELEASED(self); +return PyBool_FromLong(self->view.readonly); +} +static PyObject * +memory_ndim_get(PyObject *_self, void *Py_UNUSED(ignored)) +{ +PyMemoryViewObject *self = (PyMemoryViewObject *)_self; +CHECK_RELEASED(self); +return PyLong_FromLong(self->view.ndim); +} +static PyObject * +memory_c_contiguous(PyObject *_self, void *Py_UNUSED(ignored)) +{ +PyMemoryViewObject *self = (PyMemoryViewObject *)_self; +CHECK_RELEASED(self); +return PyBool_FromLong(MV_C_CONTIGUOUS(self->flags)); +} +static PyObject * +memory_f_contiguous(PyObject *_self, void *Py_UNUSED(ignored)) +{ +PyMemoryViewObject *self = (PyMemoryViewObject *)_self; +CHECK_RELEASED(self); +return PyBool_FromLong(MV_F_CONTIGUOUS(self->flags)); +} +static PyObject * +memory_contiguous(PyObject *_self, void *Py_UNUSED(ignored)) +{ +PyMemoryViewObject *self = (PyMemoryViewObject *)_self; +CHECK_RELEASED(self); +return PyBool_FromLong(MV_ANY_CONTIGUOUS(self->flags)); +} +PyDoc_STRVAR(memory_obj_doc, +"The underlying object of the memoryview."); +PyDoc_STRVAR(memory_nbytes_doc, +"The amount of space in bytes that the array would use in\n" +" a contiguous representation."); +PyDoc_STRVAR(memory_readonly_doc, +"A bool indicating whether the memory is read only."); +PyDoc_STRVAR(memory_itemsize_doc, +"The size in bytes of each element of the memoryview."); +PyDoc_STRVAR(memory_format_doc, +"A string containing the format (in struct module style)\n" +" for each element in the view."); +PyDoc_STRVAR(memory_ndim_doc, +"An integer indicating how many dimensions of a multi-dimensional\n" +" array the memory represents."); +PyDoc_STRVAR(memory_shape_doc, +"A tuple of ndim integers giving the shape of the memory\n" +" as an N-dimensional array."); +PyDoc_STRVAR(memory_strides_doc, +"A tuple of ndim integers giving the size in bytes to access\n" +" each element for each dimension of the array."); +PyDoc_STRVAR(memory_suboffsets_doc, +"A tuple of integers used internally for PIL-style arrays."); +PyDoc_STRVAR(memory_c_contiguous_doc, +"A bool indicating whether the memory is C contiguous."); +PyDoc_STRVAR(memory_f_contiguous_doc, +"A bool indicating whether the memory is Fortran contiguous."); +PyDoc_STRVAR(memory_contiguous_doc, +"A bool indicating whether the memory is contiguous."); +PyDoc_STRVAR(memory_exit_doc, +"__exit__($self, /, *exc_info)\n--\n\n" +"Release the underlying buffer exposed by the memoryview object."); +static PyGetSetDef memory_getsetlist[] = { +{"obj", memory_obj_get, NULL, memory_obj_doc}, +{"nbytes", memory_nbytes_get, NULL, memory_nbytes_doc}, +{"readonly", memory_readonly_get, NULL, memory_readonly_doc}, +{"itemsize", memory_itemsize_get, NULL, memory_itemsize_doc}, +{"format", memory_format_get, NULL, memory_format_doc}, +{"ndim", memory_ndim_get, NULL, memory_ndim_doc}, +{"shape", memory_shape_get, NULL, memory_shape_doc}, +{"strides", memory_strides_get, NULL, memory_strides_doc}, +{"suboffsets", memory_suboffsets_get, NULL, memory_suboffsets_doc}, +{"c_contiguous", memory_c_contiguous, NULL, memory_c_contiguous_doc}, +{"f_contiguous", memory_f_contiguous, NULL, memory_f_contiguous_doc}, +{"contiguous", memory_contiguous, NULL, memory_contiguous_doc}, +{NULL, NULL, NULL, NULL}, +}; +static PyMethodDef memory_methods[] = { +MEMORYVIEW_RELEASE_METHODDEF +MEMORYVIEW_TOBYTES_METHODDEF +MEMORYVIEW_HEX_METHODDEF +MEMORYVIEW_TOLIST_METHODDEF +MEMORYVIEW_CAST_METHODDEF +MEMORYVIEW_TOREADONLY_METHODDEF +MEMORYVIEW__FROM_FLAGS_METHODDEF +MEMORYVIEW_COUNT_METHODDEF +MEMORYVIEW_INDEX_METHODDEF +{"__enter__", memory_enter, METH_NOARGS, NULL}, +{"__exit__", memory_exit, METH_VARARGS, memory_exit_doc}, +{"__class_getitem__", Py_GenericAlias, METH_O|METH_CLASS, PyDoc_STR("See PEP 585")}, +{NULL, NULL} +}; +/**************************************************************************/ +/* Memoryview Iterator */ +/**************************************************************************/ +PyTypeObject _PyMemoryIter_Type; +typedef struct { +PyObject_HEAD +Py_ssize_t it_index; +PyMemoryViewObject *it_seq; // Set to NULL when iterator is exhausted +Py_ssize_t it_length; +const char *it_fmt; +} memoryiterobject; +static void +memoryiter_dealloc(PyObject *self) +{ +memoryiterobject *it = (memoryiterobject *)self; +_PyObject_GC_UNTRACK(it); +Py_XDECREF(it->it_seq); +PyObject_GC_Del(it); +} +static int +memoryiter_traverse(PyObject *self, visitproc visit, void *arg) +{ +memoryiterobject *it = (memoryiterobject *)self; +Py_VISIT(it->it_seq); +return 0; +} +static PyObject * +memoryiter_next(PyObject *self) +{ +memoryiterobject *it = (memoryiterobject *)self; +PyMemoryViewObject *seq; +seq = it->it_seq; +if (seq == NULL) { +return NULL; +} +if (it->it_index < it->it_length) { +CHECK_RELEASED(seq); +Py_buffer *view = &(seq->view); +char *ptr = (char *)seq->view.buf; +ptr += view->strides[0] * it->it_index++; +ptr = ADJUST_PTR(ptr, view->suboffsets, 0); +if (ptr == NULL) { +return NULL; +} +return unpack_single(seq, ptr, it->it_fmt); +} +it->it_seq = NULL; +Py_DECREF(seq); +return NULL; +} +static PyObject * +memory_iter(PyObject *seq) +{ +if (!PyMemoryView_Check(seq)) { +PyErr_BadInternalCall(); +return NULL; +} +CHECK_RELEASED(seq); +PyMemoryViewObject *obj = (PyMemoryViewObject *)seq; +int ndims = obj->view.ndim; +if (ndims == 0) { +PyErr_SetString(PyExc_TypeError, "invalid indexing of 0-dim memory"); +return NULL; +} +if (ndims != 1) { +PyErr_SetString(PyExc_NotImplementedError, +"multi-dimensional sub-views are not implemented"); +return NULL; +} +const char *fmt = adjust_fmt(&obj->view); +if (fmt == NULL) { +return NULL; +} +memoryiterobject *it; +it = PyObject_GC_New(memoryiterobject, &_PyMemoryIter_Type); +if (it == NULL) { +return NULL; +} +it->it_fmt = fmt; +it->it_length = memory_length((PyObject *)obj); +it->it_index = 0; +it->it_seq = (PyMemoryViewObject*)Py_NewRef(obj); +_PyObject_GC_TRACK(it); +return (PyObject *)it; +} +PyTypeObject _PyMemoryIter_Type = { +PyVarObject_HEAD_INIT(&PyType_Type, 0) +.tp_name = "memory_iterator", +.tp_basicsize = sizeof(memoryiterobject), +// methods +.tp_dealloc = memoryiter_dealloc, +.tp_getattro = PyObject_GenericGetAttr, +.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, +.tp_traverse = memoryiter_traverse, +.tp_iter = PyObject_SelfIter, +.tp_iternext = memoryiter_next, +}; +PyTypeObject PyMemoryView_Type = { +PyVarObject_HEAD_INIT(&PyType_Type, 0) +"memoryview", /* tp_name */ +offsetof(PyMemoryViewObject, ob_array), /* tp_basicsize */ +sizeof(Py_ssize_t), /* tp_itemsize */ +memory_dealloc, /* tp_dealloc */ +0, /* tp_vectorcall_offset */ +0, /* tp_getattr */ +0, /* tp_setattr */ +0, /* tp_as_async */ +memory_repr, /* tp_repr */ +0, /* tp_as_number */ +&memory_as_sequence, /* tp_as_sequence */ +&memory_as_mapping, /* tp_as_mapping */ +memory_hash, /* tp_hash */ +0, /* tp_call */ +0, /* tp_str */ +PyObject_GenericGetAttr, /* tp_getattro */ +0, /* tp_setattro */ +&memory_as_buffer, /* tp_as_buffer */ +Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | +Py_TPFLAGS_SEQUENCE, /* tp_flags */ +memoryview__doc__, /* tp_doc */ +memory_traverse, /* tp_traverse */ +memory_clear, /* tp_clear */ +memory_richcompare, /* tp_richcompare */ +offsetof(PyMemoryViewObject, weakreflist),/* tp_weaklistoffset */ +memory_iter, /* tp_iter */ +0, /* tp_iternext */ +memory_methods, /* tp_methods */ +0, /* tp_members */ +memory_getsetlist, /* tp_getset */ +0, /* tp_base */ +0, /* tp_dict */ +0, /* tp_descr_get */ +0, /* tp_descr_set */ +0, /* tp_dictoffset */ +0, /* tp_init */ +0, /* tp_alloc */ +memoryview, /* tp_new */ +}; + +// types.GenericAlias -- used to represent e.g. list[int]. +#include "Python.h" +#include "pycore_ceval.h" // _PyEval_GetBuiltin() +#include "pycore_modsupport.h" // _PyArg_NoKeywords() +#include "pycore_object.h" +#include "pycore_typevarobject.h" // _Py_typing_type_repr +#include "pycore_unicodeobject.h" // _PyUnicode_EqualToASCIIString() +#include "pycore_unionobject.h" // _Py_union_type_or, _PyGenericAlias_Check +#include "pycore_weakref.h" // FT_CLEAR_WEAKREFS() +#include +typedef struct { +PyObject_HEAD +PyObject *origin; +PyObject *args; +PyObject *parameters; +PyObject *weakreflist; +// Whether we're a starred type, e.g. *tuple[int]. +bool starred; +vectorcallfunc vectorcall; +} gaobject; +typedef struct { +PyObject_HEAD +PyObject *obj; /* Set to NULL when iterator is exhausted */ +} gaiterobject; +static void +ga_dealloc(PyObject *self) +{ +gaobject *alias = (gaobject *)self; +_PyObject_GC_UNTRACK(self); +FT_CLEAR_WEAKREFS(self, alias->weakreflist); +Py_XDECREF(alias->origin); +Py_XDECREF(alias->args); +Py_XDECREF(alias->parameters); +Py_TYPE(self)->tp_free(self); +} +static int +ga_traverse(PyObject *self, visitproc visit, void *arg) +{ +gaobject *alias = (gaobject *)self; +Py_VISIT(alias->origin); +Py_VISIT(alias->args); +Py_VISIT(alias->parameters); +return 0; +} +static int +ga_repr_items_list(PyUnicodeWriter *writer, PyObject *p) +{ +assert(PyList_CheckExact(p)); +Py_ssize_t len = PyList_GET_SIZE(p); +if (PyUnicodeWriter_WriteChar(writer, '[') < 0) { +return -1; +} +for (Py_ssize_t i = 0; i < len; i++) { +if (i > 0) { +if (PyUnicodeWriter_WriteASCII(writer, ", ", 2) < 0) { +return -1; +} +} +PyObject *item = PyList_GetItemRef(p, i); +if (item == NULL) { +return -1; // list can be mutated in a callback +} +if (_Py_typing_type_repr(writer, item) < 0) { +Py_DECREF(item); +return -1; +} +Py_DECREF(item); +} +if (PyUnicodeWriter_WriteChar(writer, ']') < 0) { +return -1; +} +return 0; +} +static PyObject * +ga_repr(PyObject *self) +{ +gaobject *alias = (gaobject *)self; +Py_ssize_t len = PyTuple_GET_SIZE(alias->args); +// Estimation based on the shortest format: "int[int, int, int]" +Py_ssize_t estimate = (len <= PY_SSIZE_T_MAX / 5) ? len * 5 : len; +estimate = 3 + 1 + estimate + 1; +PyUnicodeWriter *writer = PyUnicodeWriter_Create(estimate); +if (writer == NULL) { +return NULL; +} +if (alias->starred) { +if (PyUnicodeWriter_WriteChar(writer, '*') < 0) { +goto error; +} +} +if (_Py_typing_type_repr(writer, alias->origin) < 0) { +goto error; +} +if (PyUnicodeWriter_WriteChar(writer, '[') < 0) { +goto error; +} +for (Py_ssize_t i = 0; i < len; i++) { +if (i > 0) { +if (PyUnicodeWriter_WriteASCII(writer, ", ", 2) < 0) { +goto error; +} +} +PyObject *p = PyTuple_GET_ITEM(alias->args, i); +if (PyList_CheckExact(p)) { +// Looks like we are working with ParamSpec's list of type args: +if (ga_repr_items_list(writer, p) < 0) { +goto error; +} +} +else if (_Py_typing_type_repr(writer, p) < 0) { +goto error; +} +} +if (len == 0) { +// for something like tuple[()] we should print a "()" +if (PyUnicodeWriter_WriteASCII(writer, "()", 2) < 0) { +goto error; +} +} +if (PyUnicodeWriter_WriteChar(writer, ']') < 0) { +goto error; +} +return PyUnicodeWriter_Finish(writer); +error: +PyUnicodeWriter_Discard(writer); +return NULL; +} +// Index of item in self[:len], or -1 if not found (self is a tuple) +static Py_ssize_t +tuple_index(PyObject *self, Py_ssize_t len, PyObject *item) +{ +for (Py_ssize_t i = 0; i < len; i++) { +if (PyTuple_GET_ITEM(self, i) == item) { +return i; +} +} +return -1; +} +static int +tuple_add(PyObject *self, Py_ssize_t len, PyObject *item) +{ +if (tuple_index(self, len, item) < 0) { +PyTuple_SET_ITEM(self, len, Py_NewRef(item)); +return 1; +} +return 0; +} +static Py_ssize_t +tuple_extend(PyObject **dst, Py_ssize_t dstindex, +PyObject **src, Py_ssize_t count) +{ +assert(count >= 0); +if (_PyTuple_Resize(dst, PyTuple_GET_SIZE(*dst) + count - 1) != 0) { +return -1; +} +assert(dstindex + count <= PyTuple_GET_SIZE(*dst)); +for (Py_ssize_t i = 0; i < count; ++i) { +PyObject *item = src[i]; +PyTuple_SET_ITEM(*dst, dstindex + i, Py_NewRef(item)); +} +return dstindex + count; +} +PyObject * +_Py_make_parameters(PyObject *args) +{ +assert(PyTuple_Check(args) || PyList_Check(args)); +const bool is_args_list = PyList_Check(args); +PyObject *tuple_args = NULL; +if (is_args_list) { +args = tuple_args = PySequence_Tuple(args); +if (args == NULL) { +return NULL; +} +} +Py_ssize_t nargs = PyTuple_GET_SIZE(args); +Py_ssize_t len = nargs; +PyObject *parameters = PyTuple_New(len); +if (parameters == NULL) { +Py_XDECREF(tuple_args); +return NULL; +} +Py_ssize_t iparam = 0; +for (Py_ssize_t iarg = 0; iarg < nargs; iarg++) { +PyObject *t = PyTuple_GET_ITEM(args, iarg); +// We don't want __parameters__ descriptor of a bare Python class. +if (PyType_Check(t)) { +continue; +} +int rc = PyObject_HasAttrWithError(t, &_Py_ID(__typing_subst__)); +if (rc < 0) { +Py_DECREF(parameters); +Py_XDECREF(tuple_args); +return NULL; +} +if (rc) { +iparam += tuple_add(parameters, iparam, t); +} +else { +PyObject *subparams; +if (PyObject_GetOptionalAttr(t, &_Py_ID(__parameters__), +&subparams) < 0) { +Py_DECREF(parameters); +Py_XDECREF(tuple_args); +return NULL; +} +if (!subparams && (PyTuple_Check(t) || PyList_Check(t))) { +// Recursively call _Py_make_parameters for lists/tuples and +// add the results to the current parameters. +subparams = _Py_make_parameters(t); +if (subparams == NULL) { +Py_DECREF(parameters); +Py_XDECREF(tuple_args); +return NULL; +} +} +if (subparams && PyTuple_Check(subparams)) { +Py_ssize_t len2 = PyTuple_GET_SIZE(subparams); +Py_ssize_t needed = len2 - 1 - (iarg - iparam); +if (needed > 0) { +len += needed; +if (_PyTuple_Resize(¶meters, len) < 0) { +Py_DECREF(subparams); +Py_DECREF(parameters); +Py_XDECREF(tuple_args); +return NULL; +} +} +for (Py_ssize_t j = 0; j < len2; j++) { +PyObject *t2 = PyTuple_GET_ITEM(subparams, j); +iparam += tuple_add(parameters, iparam, t2); +} +} +Py_XDECREF(subparams); +} +} +if (iparam < len) { +if (_PyTuple_Resize(¶meters, iparam) < 0) { +Py_XDECREF(parameters); +Py_XDECREF(tuple_args); +return NULL; +} +} +Py_XDECREF(tuple_args); +return parameters; +} +/* If obj is a generic alias, substitute type variables params +with substitutions argitems. For example, if obj is list[T], +params is (T, S), and argitems is (str, int), return list[str]. +If obj doesn't have a __parameters__ attribute or that's not +a non-empty tuple, return a new reference to obj. */ +static PyObject * +subs_tvars(PyObject *obj, PyObject *params, +PyObject **argitems, Py_ssize_t nargs) +{ +PyObject *subparams; +if (PyObject_GetOptionalAttr(obj, &_Py_ID(__parameters__), &subparams) < 0) { +return NULL; +} +if (subparams && PyTuple_Check(subparams) && PyTuple_GET_SIZE(subparams)) { +Py_ssize_t nparams = PyTuple_GET_SIZE(params); +Py_ssize_t nsubargs = PyTuple_GET_SIZE(subparams); +PyObject *subargs = PyTuple_New(nsubargs); +if (subargs == NULL) { +Py_DECREF(subparams); +return NULL; +} +Py_ssize_t j = 0; +for (Py_ssize_t i = 0; i < nsubargs; ++i) { +PyObject *arg = PyTuple_GET_ITEM(subparams, i); +Py_ssize_t iparam = tuple_index(params, nparams, arg); +if (iparam >= 0) { +PyObject *param = PyTuple_GET_ITEM(params, iparam); +arg = argitems[iparam]; +if (Py_TYPE(param)->tp_iter && PyTuple_Check(arg)) { // TypeVarTuple +j = tuple_extend(&subargs, j, +&PyTuple_GET_ITEM(arg, 0), +PyTuple_GET_SIZE(arg)); +if (j < 0) { +return NULL; +} +continue; +} +} +PyTuple_SET_ITEM(subargs, j, Py_NewRef(arg)); +j++; +} +assert(j == PyTuple_GET_SIZE(subargs)); +obj = PyObject_GetItem(obj, subargs); +Py_DECREF(subargs); +} +else { +Py_INCREF(obj); +} +Py_XDECREF(subparams); +return obj; +} +static int +_is_unpacked_typevartuple(PyObject *arg) +{ +PyObject *tmp; +if (PyType_Check(arg)) { // TODO: Add test +return 0; +} +int res = PyObject_GetOptionalAttr(arg, &_Py_ID(__typing_is_unpacked_typevartuple__), &tmp); +if (res > 0) { +res = PyObject_IsTrue(tmp); +Py_DECREF(tmp); +} +return res; +} +static PyObject * +_unpacked_tuple_args(PyObject *arg) +{ +PyObject *result; +assert(!PyType_Check(arg)); +// Fast path +if (_PyGenericAlias_Check(arg) && +((gaobject *)arg)->starred && +((gaobject *)arg)->origin == (PyObject *)&PyTuple_Type) +{ +result = ((gaobject *)arg)->args; +return Py_NewRef(result); +} +if (PyObject_GetOptionalAttr(arg, &_Py_ID(__typing_unpacked_tuple_args__), &result) > 0) { +if (result == Py_None) { +Py_DECREF(result); +return NULL; +} +return result; +} +return NULL; +} +static PyObject * +_unpack_args(PyObject *item) +{ +PyObject *newargs = PyList_New(0); +if (newargs == NULL) { +return NULL; +} +int is_tuple = PyTuple_Check(item); +Py_ssize_t nitems = is_tuple ? PyTuple_GET_SIZE(item) : 1; +PyObject **argitems = is_tuple ? &PyTuple_GET_ITEM(item, 0) : &item; +for (Py_ssize_t i = 0; i < nitems; i++) { +item = argitems[i]; +if (!PyType_Check(item)) { +PyObject *subargs = _unpacked_tuple_args(item); +if (subargs != NULL && +PyTuple_Check(subargs) && +!(PyTuple_GET_SIZE(subargs) && +PyTuple_GET_ITEM(subargs, PyTuple_GET_SIZE(subargs)-1) == Py_Ellipsis)) +{ +if (PyList_SetSlice(newargs, PY_SSIZE_T_MAX, PY_SSIZE_T_MAX, subargs) < 0) { +Py_DECREF(subargs); +Py_DECREF(newargs); +return NULL; +} +Py_DECREF(subargs); +continue; +} +Py_XDECREF(subargs); +if (PyErr_Occurred()) { +Py_DECREF(newargs); +return NULL; +} +} +if (PyList_Append(newargs, item) < 0) { +Py_DECREF(newargs); +return NULL; +} +} +Py_SETREF(newargs, PySequence_Tuple(newargs)); +return newargs; +} +PyObject * +_Py_subs_parameters(PyObject *self, PyObject *args, PyObject *parameters, PyObject *item) +{ +Py_ssize_t nparams = PyTuple_GET_SIZE(parameters); +if (nparams == 0) { +return PyErr_Format(PyExc_TypeError, +"%R is not a generic class", +self); +} +item = _unpack_args(item); +for (Py_ssize_t i = 0; i < nparams; i++) { +PyObject *param = PyTuple_GET_ITEM(parameters, i); +PyObject *prepare, *tmp; +if (PyObject_GetOptionalAttr(param, &_Py_ID(__typing_prepare_subst__), &prepare) < 0) { +Py_DECREF(item); +return NULL; +} +if (prepare && prepare != Py_None) { +if (PyTuple_Check(item)) { +tmp = PyObject_CallFunction(prepare, "OO", self, item); +} +else { +tmp = PyObject_CallFunction(prepare, "O(O)", self, item); +} +Py_DECREF(prepare); +Py_SETREF(item, tmp); +if (item == NULL) { +return NULL; +} +} +} +int is_tuple = PyTuple_Check(item); +Py_ssize_t nitems = is_tuple ? PyTuple_GET_SIZE(item) : 1; +PyObject **argitems = is_tuple ? &PyTuple_GET_ITEM(item, 0) : &item; +if (nitems != nparams) { +Py_DECREF(item); +return PyErr_Format(PyExc_TypeError, +"Too %s arguments for %R; actual %zd, expected %zd", +nitems > nparams ? "many" : "few", +self, nitems, nparams); +} +/* Replace all type variables (specified by parameters) +with corresponding values specified by argitems. +t = list[T]; t[int] -> newargs = [int] +t = dict[str, T]; t[int] -> newargs = [str, int] +t = dict[T, list[S]]; t[str, int] -> newargs = [str, list[int]] +t = list[[T]]; t[str] -> newargs = [[str]] +*/ +assert (PyTuple_Check(args) || PyList_Check(args)); +const bool is_args_list = PyList_Check(args); +PyObject *tuple_args = NULL; +if (is_args_list) { +args = tuple_args = PySequence_Tuple(args); +if (args == NULL) { +return NULL; +} +} +Py_ssize_t nargs = PyTuple_GET_SIZE(args); +PyObject *newargs = PyTuple_New(nargs); +if (newargs == NULL) { +Py_DECREF(item); +Py_XDECREF(tuple_args); +return NULL; +} +for (Py_ssize_t iarg = 0, jarg = 0; iarg < nargs; iarg++) { +PyObject *arg = PyTuple_GET_ITEM(args, iarg); +if (PyType_Check(arg)) { +PyTuple_SET_ITEM(newargs, jarg, Py_NewRef(arg)); +jarg++; +continue; +} +// Recursively substitute params in lists/tuples. +if (PyTuple_Check(arg) || PyList_Check(arg)) { +PyObject *subargs = _Py_subs_parameters(self, arg, parameters, item); +if (subargs == NULL) { +Py_DECREF(newargs); +Py_DECREF(item); +Py_XDECREF(tuple_args); +return NULL; +} +if (PyTuple_Check(arg)) { +PyTuple_SET_ITEM(newargs, jarg, subargs); +} +else { +// _Py_subs_parameters returns a tuple. If the original arg was a list, +// convert subargs to a list as well. +PyObject *subargs_list = PySequence_List(subargs); +Py_DECREF(subargs); +if (subargs_list == NULL) { +Py_DECREF(newargs); +Py_DECREF(item); +Py_XDECREF(tuple_args); +return NULL; +} +PyTuple_SET_ITEM(newargs, jarg, subargs_list); +} +jarg++; +continue; +} +int unpack = _is_unpacked_typevartuple(arg); +if (unpack < 0) { +Py_DECREF(newargs); +Py_DECREF(item); +Py_XDECREF(tuple_args); +return NULL; +} +PyObject *subst; +if (PyObject_GetOptionalAttr(arg, &_Py_ID(__typing_subst__), &subst) < 0) { +Py_DECREF(newargs); +Py_DECREF(item); +Py_XDECREF(tuple_args); +return NULL; +} +if (subst) { +Py_ssize_t iparam = tuple_index(parameters, nparams, arg); +assert(iparam >= 0); +arg = PyObject_CallOneArg(subst, argitems[iparam]); +Py_DECREF(subst); +} +else { +arg = subs_tvars(arg, parameters, argitems, nitems); +} +if (arg == NULL) { +Py_DECREF(newargs); +Py_DECREF(item); +Py_XDECREF(tuple_args); +return NULL; +} +if (unpack) { +if (!PyTuple_Check(arg)) { +Py_DECREF(newargs); +Py_DECREF(item); +Py_XDECREF(tuple_args); +PyObject *original = PyTuple_GET_ITEM(args, iarg); +PyErr_Format(PyExc_TypeError, +"expected __typing_subst__ of %T objects to return a tuple, not %T", +original, arg); +Py_DECREF(arg); +return NULL; +} +jarg = tuple_extend(&newargs, jarg, +&PyTuple_GET_ITEM(arg, 0), PyTuple_GET_SIZE(arg)); +Py_DECREF(arg); +if (jarg < 0) { +Py_DECREF(item); +Py_XDECREF(tuple_args); +assert(newargs == NULL); +return NULL; +} +} +else { +PyTuple_SET_ITEM(newargs, jarg, arg); +jarg++; +} +} +Py_DECREF(item); +Py_XDECREF(tuple_args); +return newargs; +} +PyDoc_STRVAR(genericalias__doc__, +"GenericAlias(origin, args, /)\n" +"--\n\n" +"Represent a PEP 585 generic type\n" +"\n" +"E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,)."); +static PyObject * +ga_getitem(PyObject *self, PyObject *item) +{ +gaobject *alias = (gaobject *)self; +// Populate __parameters__ if needed. +if (alias->parameters == NULL) { +alias->parameters = _Py_make_parameters(alias->args); +if (alias->parameters == NULL) { +return NULL; +} +} +PyObject *newargs = _Py_subs_parameters(self, alias->args, alias->parameters, item); +if (newargs == NULL) { +return NULL; +} +PyObject *res = Py_GenericAlias(alias->origin, newargs); +if (res == NULL) { +Py_DECREF(newargs); +return NULL; +} +((gaobject *)res)->starred = alias->starred; +Py_DECREF(newargs); +return res; +} +static PyMappingMethods ga_as_mapping = { +.mp_subscript = ga_getitem, +}; +static Py_hash_t +ga_hash(PyObject *self) +{ +gaobject *alias = (gaobject *)self; +// TODO: Hash in the hash for the origin +Py_hash_t h0 = PyObject_Hash(alias->origin); +if (h0 == -1) { +return -1; +} +Py_hash_t h1 = PyObject_Hash(alias->args); +if (h1 == -1) { +return -1; +} +return h0 ^ h1; +} +static inline PyObject * +set_orig_class(PyObject *obj, PyObject *self) +{ +if (obj != NULL) { +if (PyObject_SetAttr(obj, &_Py_ID(__orig_class__), self) < 0) { +if (!PyErr_ExceptionMatches(PyExc_AttributeError) && +!PyErr_ExceptionMatches(PyExc_TypeError)) +{ +Py_DECREF(obj); +return NULL; +} +PyErr_Clear(); +} +} +return obj; +} +static PyObject * +ga_call(PyObject *self, PyObject *args, PyObject *kwds) +{ +gaobject *alias = (gaobject *)self; +PyObject *obj = PyObject_Call(alias->origin, args, kwds); +return set_orig_class(obj, self); +} +static PyObject * +ga_vectorcall(PyObject *self, PyObject *const *args, +size_t nargsf, PyObject *kwnames) +{ +gaobject *alias = (gaobject *) self; +PyObject *obj = PyVectorcall_Function(alias->origin)(alias->origin, args, nargsf, kwnames); +return set_orig_class(obj, self); +} +static const char* const attr_exceptions[] = { +"__class__", +"__origin__", +"__args__", +"__unpacked__", +"__parameters__", +"__typing_unpacked_tuple_args__", +"__mro_entries__", +"__reduce_ex__", // needed so we don't look up object.__reduce_ex__ +"__reduce__", +NULL, +}; +static const char* const attr_blocked[] = { +"__bases__", +"__copy__", +"__deepcopy__", +NULL, +}; +static PyObject * +ga_getattro(PyObject *self, PyObject *name) +{ +gaobject *alias = (gaobject *)self; +if (PyUnicode_Check(name)) { +// When we check blocked attrs, we don't allow to proxy them to `__origin__`. +// Otherwise, we can break existing code. +for (const char * const *p = attr_blocked; ; p++) { +if (*p == NULL) { +break; +} +if (_PyUnicode_EqualToASCIIString(name, *p)) { +goto generic_getattr; +} +} +// When we see own attrs, it has a priority over `__origin__`'s attr. +for (const char * const *p = attr_exceptions; ; p++) { +if (*p == NULL) { +return PyObject_GetAttr(alias->origin, name); +} +if (_PyUnicode_EqualToASCIIString(name, *p)) { +goto generic_getattr; +} +} +} +generic_getattr: +return PyObject_GenericGetAttr(self, name); +} +static PyObject * +ga_richcompare(PyObject *a, PyObject *b, int op) +{ +if (!_PyGenericAlias_Check(b) || +(op != Py_EQ && op != Py_NE)) +{ +Py_RETURN_NOTIMPLEMENTED; +} +if (op == Py_NE) { +PyObject *eq = ga_richcompare(a, b, Py_EQ); +if (eq == NULL) +return NULL; +Py_DECREF(eq); +if (eq == Py_True) { +Py_RETURN_FALSE; +} +else { +Py_RETURN_TRUE; +} +} +gaobject *aa = (gaobject *)a; +gaobject *bb = (gaobject *)b; +if (aa->starred != bb->starred) { +Py_RETURN_FALSE; +} +int eq = PyObject_RichCompareBool(aa->origin, bb->origin, Py_EQ); +if (eq < 0) { +return NULL; +} +if (!eq) { +Py_RETURN_FALSE; +} +return PyObject_RichCompare(aa->args, bb->args, Py_EQ); +} +static PyObject * +ga_mro_entries(PyObject *self, PyObject *args) +{ +gaobject *alias = (gaobject *)self; +return PyTuple_Pack(1, alias->origin); +} +static PyObject * +ga_instancecheck(PyObject *self, PyObject *Py_UNUSED(ignored)) +{ +PyErr_SetString(PyExc_TypeError, +"isinstance() argument 2 cannot be a parameterized generic"); +return NULL; +} +static PyObject * +ga_subclasscheck(PyObject *self, PyObject *Py_UNUSED(ignored)) +{ +PyErr_SetString(PyExc_TypeError, +"issubclass() argument 2 cannot be a parameterized generic"); +return NULL; +} +static PyObject * +ga_reduce(PyObject *self, PyObject *Py_UNUSED(ignored)) +{ +gaobject *alias = (gaobject *)self; +if (alias->starred) { +PyObject *tmp = Py_GenericAlias(alias->origin, alias->args); +if (tmp != NULL) { +Py_SETREF(tmp, PyObject_GetIter(tmp)); +} +if (tmp == NULL) { +return NULL; +} +return Py_BuildValue("N(N)", _PyEval_GetBuiltin(&_Py_ID(next)), tmp); +} +return Py_BuildValue("O(OO)", Py_TYPE(alias), +alias->origin, alias->args); +} +static PyObject * +ga_dir(PyObject *self, PyObject *Py_UNUSED(ignored)) +{ +gaobject *alias = (gaobject *)self; +PyObject *dir = PyObject_Dir(alias->origin); +if (dir == NULL) { +return NULL; +} +PyObject *dir_entry = NULL; +for (const char * const *p = attr_exceptions; ; p++) { +if (*p == NULL) { +break; +} +else { +dir_entry = PyUnicode_FromString(*p); +if (dir_entry == NULL) { +goto error; +} +int contains = PySequence_Contains(dir, dir_entry); +if (contains < 0) { +goto error; +} +if (contains == 0 && PyList_Append(dir, dir_entry) < 0) { +goto error; +} +Py_CLEAR(dir_entry); +} +} +return dir; +error: +Py_DECREF(dir); +Py_XDECREF(dir_entry); +return NULL; +} +static PyMethodDef ga_methods[] = { +{"__mro_entries__", ga_mro_entries, METH_O}, +{"__instancecheck__", ga_instancecheck, METH_O}, +{"__subclasscheck__", ga_subclasscheck, METH_O}, +{"__reduce__", ga_reduce, METH_NOARGS}, +{"__dir__", ga_dir, METH_NOARGS}, +{0} +}; +static PyMemberDef ga_members[] = { +{"__origin__", _Py_T_OBJECT, offsetof(gaobject, origin), Py_READONLY}, +{"__args__", _Py_T_OBJECT, offsetof(gaobject, args), Py_READONLY}, +{"__unpacked__", Py_T_BOOL, offsetof(gaobject, starred), Py_READONLY}, +{0} +}; +static PyObject * +ga_parameters(PyObject *self, void *unused) +{ +gaobject *alias = (gaobject *)self; +if (alias->parameters == NULL) { +alias->parameters = _Py_make_parameters(alias->args); +if (alias->parameters == NULL) { +return NULL; +} +} +return Py_NewRef(alias->parameters); +} +static PyObject * +ga_unpacked_tuple_args(PyObject *self, void *unused) +{ +gaobject *alias = (gaobject *)self; +if (alias->starred && alias->origin == (PyObject *)&PyTuple_Type) { +return Py_NewRef(alias->args); +} +Py_RETURN_NONE; +} +static PyGetSetDef ga_properties[] = { +{"__parameters__", ga_parameters, NULL, PyDoc_STR("Type variables in the GenericAlias."), NULL}, +{"__typing_unpacked_tuple_args__", ga_unpacked_tuple_args, NULL, NULL}, +{0} +}; +/* A helper function to create GenericAlias' args tuple and set its attributes. +* Returns 1 on success, 0 on failure. +*/ +static inline int +setup_ga(gaobject *alias, PyObject *origin, PyObject *args) { +if (!PyTuple_Check(args)) { +args = PyTuple_Pack(1, args); +if (args == NULL) { +return 0; +} +} +else { +Py_INCREF(args); +} +alias->origin = Py_NewRef(origin); +alias->args = args; +alias->parameters = NULL; +alias->weakreflist = NULL; +if (PyVectorcall_Function(origin) != NULL) { +alias->vectorcall = ga_vectorcall; +} +else { +alias->vectorcall = NULL; +} +return 1; +} +static PyObject * +ga_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ +if (!_PyArg_NoKeywords("GenericAlias", kwds)) { +return NULL; +} +if (!_PyArg_CheckPositional("GenericAlias", PyTuple_GET_SIZE(args), 2, 2)) { +return NULL; +} +PyObject *origin = PyTuple_GET_ITEM(args, 0); +PyObject *arguments = PyTuple_GET_ITEM(args, 1); +gaobject *self = (gaobject *)type->tp_alloc(type, 0); +if (self == NULL) { +return NULL; +} +if (!setup_ga(self, origin, arguments)) { +Py_DECREF(self); +return NULL; +} +return (PyObject *)self; +} +static PyNumberMethods ga_as_number = { +.nb_or = _Py_union_type_or, // Add __or__ function +}; +static PyObject * +ga_iternext(PyObject *op) +{ +gaiterobject *gi = (gaiterobject*)op; +if (gi->obj == NULL) { +PyErr_SetNone(PyExc_StopIteration); +return NULL; +} +gaobject *alias = (gaobject *)gi->obj; +PyObject *starred_alias = Py_GenericAlias(alias->origin, alias->args); +if (starred_alias == NULL) { +return NULL; +} +((gaobject *)starred_alias)->starred = true; +Py_SETREF(gi->obj, NULL); +return starred_alias; +} +static void +ga_iter_dealloc(PyObject *op) +{ +gaiterobject *gi = (gaiterobject*)op; +PyObject_GC_UnTrack(gi); +Py_XDECREF(gi->obj); +PyObject_GC_Del(gi); +} +static int +ga_iter_traverse(PyObject *op, visitproc visit, void *arg) +{ +gaiterobject *gi = (gaiterobject*)op; +Py_VISIT(gi->obj); +return 0; +} +static int +ga_iter_clear(PyObject *self) +{ +gaiterobject *gi = (gaiterobject *)self; +Py_CLEAR(gi->obj); +return 0; +} +static PyObject * +ga_iter_reduce(PyObject *self, PyObject *Py_UNUSED(ignored)) +{ +PyObject *iter = _PyEval_GetBuiltin(&_Py_ID(iter)); +gaiterobject *gi = (gaiterobject *)self; +/* _PyEval_GetBuiltin can invoke arbitrary code, +* call must be before access of iterator pointers. +* see issue #101765 */ +if (gi->obj) +return Py_BuildValue("N(O)", iter, gi->obj); +else +return Py_BuildValue("N(())", iter); +} +static PyMethodDef ga_iter_methods[] = { +{"__reduce__", ga_iter_reduce, METH_NOARGS}, +{0} +}; +// gh-91632: _Py_GenericAliasIterType is exported to be cleared +// in _PyTypes_FiniTypes. +PyTypeObject _Py_GenericAliasIterType = { +PyVarObject_HEAD_INIT(&PyType_Type, 0) +.tp_name = "generic_alias_iterator", +.tp_basicsize = sizeof(gaiterobject), +.tp_iter = PyObject_SelfIter, +.tp_iternext = ga_iternext, +.tp_traverse = ga_iter_traverse, +.tp_methods = ga_iter_methods, +.tp_dealloc = ga_iter_dealloc, +.tp_clear = ga_iter_clear, +.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, +}; +static PyObject * +ga_iter(PyObject *self) { +gaiterobject *gi = PyObject_GC_New(gaiterobject, &_Py_GenericAliasIterType); +if (gi == NULL) { +return NULL; +} +gi->obj = Py_NewRef(self); +PyObject_GC_Track(gi); +return (PyObject *)gi; +} +// TODO: +// - argument clinic? +// - cache? +PyTypeObject Py_GenericAliasType = { +PyVarObject_HEAD_INIT(&PyType_Type, 0) +.tp_name = "types.GenericAlias", +.tp_doc = genericalias__doc__, +.tp_basicsize = sizeof(gaobject), +.tp_dealloc = ga_dealloc, +.tp_repr = ga_repr, +.tp_as_number = &ga_as_number, // allow X | Y of GenericAlias objs +.tp_as_mapping = &ga_as_mapping, +.tp_hash = ga_hash, +.tp_call = ga_call, +.tp_getattro = ga_getattro, +.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_VECTORCALL, +.tp_traverse = ga_traverse, +.tp_richcompare = ga_richcompare, +.tp_weaklistoffset = offsetof(gaobject, weakreflist), +.tp_methods = ga_methods, +.tp_members = ga_members, +.tp_alloc = PyType_GenericAlloc, +.tp_new = ga_new, +.tp_free = PyObject_GC_Del, +.tp_getset = ga_properties, +.tp_iter = ga_iter, +.tp_vectorcall_offset = offsetof(gaobject, vectorcall), +}; +PyObject * +Py_GenericAlias(PyObject *origin, PyObject *args) +{ +gaobject *alias = (gaobject*) PyType_GenericAlloc( +(PyTypeObject *)&Py_GenericAliasType, 0); +if (alias == NULL) { +return NULL; +} +if (!setup_ga(alias, origin, args)) { +Py_DECREF(alias); +return NULL; +} +return (PyObject *)alias; +} + +/* Class object implementation (dead now except for methods) */ +#include "Python.h" +#include "pycore_call.h" // _PyObject_VectorcallTstate() +#include "pycore_ceval.h" // _PyEval_GetBuiltin() +#include "pycore_freelist.h" +#include "pycore_object.h" +#include "pycore_pyerrors.h" +#include "pycore_pystate.h" // _PyThreadState_GET() +#include "pycore_weakref.h" // FT_CLEAR_WEAKREFS() +#include "clinic/classobject.c.h" +#define _PyMethodObject_CAST(op) _Py_CAST(PyMethodObject*, (op)) +#define TP_DESCR_GET(t) ((t)->tp_descr_get) +/*[clinic input] +class method "PyMethodObject *" "&PyMethod_Type" +[clinic start generated code]*/ +/*[clinic end generated code: output=da39a3ee5e6b4b0d input=b16e47edf6107c23]*/ +PyObject * +PyMethod_Function(PyObject *im) +{ +if (!PyMethod_Check(im)) { +PyErr_BadInternalCall(); +return NULL; +} +return ((PyMethodObject *)im)->im_func; +} +PyObject * +PyMethod_Self(PyObject *im) +{ +if (!PyMethod_Check(im)) { +PyErr_BadInternalCall(); +return NULL; +} +return ((PyMethodObject *)im)->im_self; +} +static PyObject * +method_vectorcall(PyObject *method, PyObject *const *args, +size_t nargsf, PyObject *kwnames) +{ +assert(Py_IS_TYPE(method, &PyMethod_Type)); +PyThreadState *tstate = _PyThreadState_GET(); +PyObject *self = PyMethod_GET_SELF(method); +PyObject *func = PyMethod_GET_FUNCTION(method); +Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +assert(nargs == 0 || args[nargs-1]); +PyObject *result; +if (nargsf & PY_VECTORCALL_ARGUMENTS_OFFSET) { +/* PY_VECTORCALL_ARGUMENTS_OFFSET is set, so we are allowed to mutate the vector */ +PyObject **newargs = (PyObject**)args - 1; +nargs += 1; +PyObject *tmp = newargs[0]; +newargs[0] = self; +assert(newargs[nargs-1]); +result = _PyObject_VectorcallTstate(tstate, func, newargs, +nargs, kwnames); +newargs[0] = tmp; +} +else { +Py_ssize_t nkwargs = (kwnames == NULL) ? 0 : PyTuple_GET_SIZE(kwnames); +Py_ssize_t totalargs = nargs + nkwargs; +if (totalargs == 0) { +return _PyObject_VectorcallTstate(tstate, func, &self, 1, NULL); +} +PyObject *newargs_stack[_PY_FASTCALL_SMALL_STACK]; +PyObject **newargs; +if (totalargs <= (Py_ssize_t)Py_ARRAY_LENGTH(newargs_stack) - 1) { +newargs = newargs_stack; +} +else { +newargs = PyMem_Malloc((totalargs+1) * sizeof(PyObject *)); +if (newargs == NULL) { +_PyErr_NoMemory(tstate); +return NULL; +} +} +/* use borrowed references */ +newargs[0] = self; +/* bpo-37138: since totalargs > 0, it's impossible that args is NULL. +* We need this, since calling memcpy() with a NULL pointer is +* undefined behaviour. */ +assert(args != NULL); +memcpy(newargs + 1, args, totalargs * sizeof(PyObject *)); +result = _PyObject_VectorcallTstate(tstate, func, +newargs, nargs+1, kwnames); +if (newargs != newargs_stack) { +PyMem_Free(newargs); +} +} +return result; +} +/* Method objects are used for bound instance methods returned by +instancename.methodname. ClassName.methodname returns an ordinary +function. +*/ +PyObject * +PyMethod_New(PyObject *func, PyObject *self) +{ +if (self == NULL) { +PyErr_BadInternalCall(); +return NULL; +} +PyMethodObject *im = _Py_FREELIST_POP(PyMethodObject, pymethodobjects); +if (im == NULL) { +im = PyObject_GC_New(PyMethodObject, &PyMethod_Type); +if (im == NULL) { +return NULL; +} +} +im->im_weakreflist = NULL; +im->im_func = Py_NewRef(func); +im->im_self = Py_NewRef(self); +im->vectorcall = method_vectorcall; +_PyObject_GC_TRACK(im); +return (PyObject *)im; +} +/*[clinic input] +method.__reduce__ +[clinic start generated code]*/ +static PyObject * +method___reduce___impl(PyMethodObject *self) +/*[clinic end generated code: output=6c04506d0fa6fdcb input=143a0bf5e96de6e8]*/ +{ +PyObject *funcself = PyMethod_GET_SELF(self); +PyObject *func = PyMethod_GET_FUNCTION(self); +PyObject *funcname = PyObject_GetAttr(func, &_Py_ID(__name__)); +if (funcname == NULL) { +return NULL; +} +return Py_BuildValue( +"N(ON)", _PyEval_GetBuiltin(&_Py_ID(getattr)), funcself, funcname); +} +static PyMethodDef method_methods[] = { +METHOD___REDUCE___METHODDEF +{NULL, NULL} +}; +/* Descriptors for PyMethod attributes */ +/* im_func and im_self are stored in the PyMethod object */ +#define MO_OFF(x) offsetof(PyMethodObject, x) +static PyMemberDef method_memberlist[] = { +{"__func__", _Py_T_OBJECT, MO_OFF(im_func), Py_READONLY, +"the function (or other callable) implementing a method"}, +{"__self__", _Py_T_OBJECT, MO_OFF(im_self), Py_READONLY, +"the instance to which a method is bound"}, +{NULL} /* Sentinel */ +}; +/* Christian Tismer argued convincingly that method attributes should +(nearly) always override function attributes. +The one exception is __doc__; there's a default __doc__ which +should only be used for the class, not for instances */ +static PyObject * +method_get_doc(PyObject *self, void *context) +{ +PyMethodObject *im = _PyMethodObject_CAST(self); +return PyObject_GetAttr(im->im_func, &_Py_ID(__doc__)); +} +static PyGetSetDef method_getset[] = { +{"__doc__", method_get_doc, NULL, NULL}, +{0} +}; +static PyObject * +method_getattro(PyObject *obj, PyObject *name) +{ +PyMethodObject *im = (PyMethodObject *)obj; +PyTypeObject *tp = Py_TYPE(obj); +PyObject *descr = NULL; +{ +if (!_PyType_IsReady(tp)) { +if (PyType_Ready(tp) < 0) +return NULL; +} +descr = _PyType_LookupRef(tp, name); +} +if (descr != NULL) { +descrgetfunc f = TP_DESCR_GET(Py_TYPE(descr)); +if (f != NULL) { +PyObject *res = f(descr, obj, (PyObject *)Py_TYPE(obj)); +Py_DECREF(descr); +return res; +} +else { +return descr; +} +} +return PyObject_GetAttr(im->im_func, name); +} +/*[clinic input] +@classmethod +method.__new__ as method_new +function: object +instance: object +/ +Create a bound instance method object. +[clinic start generated code]*/ +static PyObject * +method_new_impl(PyTypeObject *type, PyObject *function, PyObject *instance) +/*[clinic end generated code: output=d33ef4ebf702e1f7 input=4e32facc3c3108ae]*/ +{ +if (!PyCallable_Check(function)) { +PyErr_SetString(PyExc_TypeError, +"first argument must be callable"); +return NULL; +} +if (instance == NULL || instance == Py_None) { +PyErr_SetString(PyExc_TypeError, +"instance must not be None"); +return NULL; +} +return PyMethod_New(function, instance); +} +static void +method_dealloc(PyObject *self) +{ +PyMethodObject *im = _PyMethodObject_CAST(self); +_PyObject_GC_UNTRACK(im); +FT_CLEAR_WEAKREFS(self, im->im_weakreflist); +Py_DECREF(im->im_func); +Py_XDECREF(im->im_self); +assert(Py_IS_TYPE(self, &PyMethod_Type)); +_Py_FREELIST_FREE(pymethodobjects, (PyObject *)im, PyObject_GC_Del); +} +static PyObject * +method_richcompare(PyObject *self, PyObject *other, int op) +{ +PyMethodObject *a, *b; +PyObject *res; +int eq; +if ((op != Py_EQ && op != Py_NE) || +!PyMethod_Check(self) || +!PyMethod_Check(other)) +{ +Py_RETURN_NOTIMPLEMENTED; +} +a = (PyMethodObject *)self; +b = (PyMethodObject *)other; +eq = PyObject_RichCompareBool(a->im_func, b->im_func, Py_EQ); +if (eq == 1) { +eq = (a->im_self == b->im_self); +} +else if (eq < 0) +return NULL; +if (op == Py_EQ) +res = eq ? Py_True : Py_False; +else +res = eq ? Py_False : Py_True; +return Py_NewRef(res); +} +static PyObject * +method_repr(PyObject *op) +{ +PyMethodObject *a = _PyMethodObject_CAST(op); +PyObject *self = a->im_self; +PyObject *func = a->im_func; +PyObject *funcname, *result; +const char *defname = "?"; +if (PyObject_GetOptionalAttr(func, &_Py_ID(__qualname__), &funcname) < 0 || +(funcname == NULL && +PyObject_GetOptionalAttr(func, &_Py_ID(__name__), &funcname) < 0)) +{ +return NULL; +} +if (funcname != NULL && !PyUnicode_Check(funcname)) { +Py_SETREF(funcname, NULL); +} +/* XXX Shouldn't use repr()/%R here! */ +result = PyUnicode_FromFormat("", +funcname, defname, self); +Py_XDECREF(funcname); +return result; +} +static Py_hash_t +method_hash(PyObject *self) +{ +PyMethodObject *a = _PyMethodObject_CAST(self); +Py_hash_t x = PyObject_GenericHash(a->im_self); +Py_hash_t y = PyObject_Hash(a->im_func); +if (y == -1) { +return -1; +} +x = x ^ y; +if (x == -1) { +x = -2; +} +return x; +} +static int +method_traverse(PyObject *self, visitproc visit, void *arg) +{ +PyMethodObject *im = _PyMethodObject_CAST(self); +Py_VISIT(im->im_func); +Py_VISIT(im->im_self); +return 0; +} +static PyObject * +method_descr_get(PyObject *meth, PyObject *obj, PyObject *cls) +{ +Py_INCREF(meth); +return meth; +} +PyTypeObject PyMethod_Type = { +PyVarObject_HEAD_INIT(&PyType_Type, 0) +.tp_name = "method", +.tp_basicsize = sizeof(PyMethodObject), +.tp_dealloc = method_dealloc, +.tp_vectorcall_offset = offsetof(PyMethodObject, vectorcall), +.tp_repr = method_repr, +.tp_hash = method_hash, +.tp_call = PyVectorcall_Call, +.tp_getattro = method_getattro, +.tp_setattro = PyObject_GenericSetAttr, +.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | +Py_TPFLAGS_HAVE_VECTORCALL, +.tp_doc = method_new__doc__, +.tp_traverse = method_traverse, +.tp_richcompare = method_richcompare, +.tp_weaklistoffset = offsetof(PyMethodObject, im_weakreflist), +.tp_methods = method_methods, +.tp_members = method_memberlist, +.tp_getset = method_getset, +.tp_descr_get = method_descr_get, +.tp_new = method_new, +}; +/* ------------------------------------------------------------------------ +* instance method +*/ +/*[clinic input] +class instancemethod "PyInstanceMethodObject *" "&PyInstanceMethod_Type" +[clinic start generated code]*/ +/*[clinic end generated code: output=da39a3ee5e6b4b0d input=28c9762a9016f4d2]*/ +PyObject * +PyInstanceMethod_New(PyObject *func) { +PyInstanceMethodObject *method; +method = PyObject_GC_New(PyInstanceMethodObject, +&PyInstanceMethod_Type); +if (method == NULL) return NULL; +method->func = Py_NewRef(func); +_PyObject_GC_TRACK(method); +return (PyObject *)method; +} +PyObject * +PyInstanceMethod_Function(PyObject *im) +{ +if (!PyInstanceMethod_Check(im)) { +PyErr_BadInternalCall(); +return NULL; +} +return PyInstanceMethod_GET_FUNCTION(im); +} +#define IMO_OFF(x) offsetof(PyInstanceMethodObject, x) +static PyMemberDef instancemethod_memberlist[] = { +{"__func__", _Py_T_OBJECT, IMO_OFF(func), Py_READONLY, +"the function (or other callable) implementing a method"}, +{NULL} /* Sentinel */ +}; +static PyObject * +instancemethod_get_doc(PyObject *self, void *context) +{ +return PyObject_GetAttr(PyInstanceMethod_GET_FUNCTION(self), +&_Py_ID(__doc__)); +} +static PyGetSetDef instancemethod_getset[] = { +{"__doc__", instancemethod_get_doc, NULL, NULL}, +{0} +}; +static PyObject * +instancemethod_getattro(PyObject *self, PyObject *name) +{ +PyTypeObject *tp = Py_TYPE(self); +PyObject *descr = NULL; +if (!_PyType_IsReady(tp)) { +if (PyType_Ready(tp) < 0) +return NULL; +} +descr = _PyType_LookupRef(tp, name); +if (descr != NULL) { +descrgetfunc f = TP_DESCR_GET(Py_TYPE(descr)); +if (f != NULL) { +PyObject *res = f(descr, self, (PyObject *)Py_TYPE(self)); +Py_DECREF(descr); +return res; +} +else { +return descr; +} +} +return PyObject_GetAttr(PyInstanceMethod_GET_FUNCTION(self), name); +} +static void +instancemethod_dealloc(PyObject *self) { +_PyObject_GC_UNTRACK(self); +Py_DECREF(PyInstanceMethod_GET_FUNCTION(self)); +PyObject_GC_Del(self); +} +static int +instancemethod_traverse(PyObject *self, visitproc visit, void *arg) { +Py_VISIT(PyInstanceMethod_GET_FUNCTION(self)); +return 0; +} +static PyObject * +instancemethod_call(PyObject *self, PyObject *arg, PyObject *kw) +{ +return PyObject_Call(PyInstanceMethod_GET_FUNCTION(self), arg, kw); +} +static PyObject * +instancemethod_descr_get(PyObject *descr, PyObject *obj, PyObject *type) { +PyObject *func = PyInstanceMethod_GET_FUNCTION(descr); +if (obj == NULL) { +return Py_NewRef(func); +} +else +return PyMethod_New(func, obj); +} +static PyObject * +instancemethod_richcompare(PyObject *self, PyObject *other, int op) +{ +PyInstanceMethodObject *a, *b; +PyObject *res; +int eq; +if ((op != Py_EQ && op != Py_NE) || +!PyInstanceMethod_Check(self) || +!PyInstanceMethod_Check(other)) +{ +Py_RETURN_NOTIMPLEMENTED; +} +a = (PyInstanceMethodObject *)self; +b = (PyInstanceMethodObject *)other; +eq = PyObject_RichCompareBool(a->func, b->func, Py_EQ); +if (eq < 0) +return NULL; +if (op == Py_EQ) +res = eq ? Py_True : Py_False; +else +res = eq ? Py_False : Py_True; +return Py_NewRef(res); +} +static PyObject * +instancemethod_repr(PyObject *self) +{ +PyObject *func = PyInstanceMethod_Function(self); +PyObject *funcname, *result; +const char *defname = "?"; +if (func == NULL) { +PyErr_BadInternalCall(); +return NULL; +} +if (PyObject_GetOptionalAttr(func, &_Py_ID(__name__), &funcname) < 0) { +return NULL; +} +if (funcname != NULL && !PyUnicode_Check(funcname)) { +Py_SETREF(funcname, NULL); +} +result = PyUnicode_FromFormat("", +funcname, defname, self); +Py_XDECREF(funcname); +return result; +} +/*[clinic input] +@classmethod +instancemethod.__new__ as instancemethod_new +function: object +/ +Bind a function to a class. +[clinic start generated code]*/ +static PyObject * +instancemethod_new_impl(PyTypeObject *type, PyObject *function) +/*[clinic end generated code: output=5e0397b2bdb750be input=cfc54e8b973664a8]*/ +{ +if (!PyCallable_Check(function)) { +PyErr_SetString(PyExc_TypeError, +"first argument must be callable"); +return NULL; +} +return PyInstanceMethod_New(function); +} +PyTypeObject PyInstanceMethod_Type = { +PyVarObject_HEAD_INIT(&PyType_Type, 0) +.tp_name = "instancemethod", +.tp_basicsize = sizeof(PyInstanceMethodObject), +.tp_dealloc = instancemethod_dealloc, +.tp_repr = instancemethod_repr, +.tp_call = instancemethod_call, +.tp_getattro = instancemethod_getattro, +.tp_setattro = PyObject_GenericSetAttr, +.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, +.tp_doc = instancemethod_new__doc__, +.tp_traverse = instancemethod_traverse, +.tp_richcompare = instancemethod_richcompare, +.tp_members = instancemethod_memberlist, +.tp_getset = instancemethod_getset, +.tp_descr_get = instancemethod_descr_get, +.tp_new = instancemethod_new, +}; + +/* this file was generated by Tools/unicode/makeunicodedata.py 3.3 */ +/* a list of unique character type descriptors */ +const _PyUnicode_TypeRecord _PyUnicode_TypeRecords[] = { +{0, 0, 0, 0, 0, 0}, +{0, 0, 0, 0, 0, 32}, +{0, 0, 0, 0, 0, 48}, +{0, 0, 0, 0, 0, 1056}, +{0, 0, 0, 0, 0, 1024}, +{0, 0, 0, 0, 0, 5120}, +{0, 0, 0, 0, 0, 3590}, +{0, 0, 0, 1, 1, 3590}, +{0, 0, 0, 2, 2, 3590}, +{0, 0, 0, 3, 3, 3590}, +{0, 0, 0, 4, 4, 3590}, +{0, 0, 0, 5, 5, 3590}, +{0, 0, 0, 6, 6, 3590}, +{0, 0, 0, 7, 7, 3590}, +{0, 0, 0, 8, 8, 3590}, +{0, 0, 0, 9, 9, 3590}, +{0, 32, 0, 0, 0, 10113}, +{0, 0, 0, 0, 0, 1536}, +{-32, 0, -32, 0, 0, 9993}, +{0, 0, 0, 0, 0, 9993}, +{0, 0, 0, 0, 0, 4096}, +{0, 0, 0, 0, 2, 3076}, +{0, 0, 0, 0, 3, 3076}, +{16777218, 17825792, 16777218, 0, 0, 26377}, +{0, 0, 0, 0, 0, 5632}, +{0, 0, 0, 0, 1, 3076}, +{0, 0, 0, 0, 0, 3072}, +{33554438, 18874371, 33554440, 0, 0, 26377}, +{121, 0, 121, 0, 0, 9993}, +{0, 1, 0, 0, 0, 10113}, +{-1, 0, -1, 0, 0, 9993}, +{16777228, 33554442, 16777228, 0, 0, 26497}, +{-232, 0, -232, 0, 0, 9993}, +{33554448, 18874381, 33554448, 0, 0, 26377}, +{0, -121, 0, 0, 0, 10113}, +{16777236, 17825810, 16777236, 0, 0, 26377}, +{195, 0, 195, 0, 0, 9993}, +{0, 210, 0, 0, 0, 10113}, +{0, 206, 0, 0, 0, 10113}, +{0, 205, 0, 0, 0, 10113}, +{0, 79, 0, 0, 0, 10113}, +{0, 202, 0, 0, 0, 10113}, +{0, 203, 0, 0, 0, 10113}, +{0, 207, 0, 0, 0, 10113}, +{97, 0, 97, 0, 0, 9993}, +{0, 211, 0, 0, 0, 10113}, +{0, 209, 0, 0, 0, 10113}, +{163, 0, 163, 0, 0, 9993}, +{42561, 0, 42561, 0, 0, 9993}, +{0, 213, 0, 0, 0, 10113}, +{130, 0, 130, 0, 0, 9993}, +{0, 214, 0, 0, 0, 10113}, +{0, 218, 0, 0, 0, 10113}, +{0, 217, 0, 0, 0, 10113}, +{0, 219, 0, 0, 0, 10113}, +{0, 0, 0, 0, 0, 1793}, +{56, 0, 56, 0, 0, 9993}, +{0, 2, 1, 0, 0, 10113}, +{-1, 1, 0, 0, 0, 10049}, +{-2, 0, -1, 0, 0, 9993}, +{-79, 0, -79, 0, 0, 9993}, +{33554456, 18874389, 33554456, 0, 0, 26377}, +{0, -97, 0, 0, 0, 10113}, +{0, -56, 0, 0, 0, 10113}, +{0, -130, 0, 0, 0, 10113}, +{0, 10795, 0, 0, 0, 10113}, +{0, -163, 0, 0, 0, 10113}, +{0, 10792, 0, 0, 0, 10113}, +{10815, 0, 10815, 0, 0, 9993}, +{0, -195, 0, 0, 0, 10113}, +{0, 69, 0, 0, 0, 10113}, +{0, 71, 0, 0, 0, 10113}, +{10783, 0, 10783, 0, 0, 9993}, +{10780, 0, 10780, 0, 0, 9993}, +{10782, 0, 10782, 0, 0, 9993}, +{-210, 0, -210, 0, 0, 9993}, +{-206, 0, -206, 0, 0, 9993}, +{-205, 0, -205, 0, 0, 9993}, +{-202, 0, -202, 0, 0, 9993}, +{-203, 0, -203, 0, 0, 9993}, +{42319, 0, 42319, 0, 0, 9993}, +{42315, 0, 42315, 0, 0, 9993}, +{-207, 0, -207, 0, 0, 9993}, +{42343, 0, 42343, 0, 0, 9993}, +{42280, 0, 42280, 0, 0, 9993}, +{42308, 0, 42308, 0, 0, 9993}, +{-209, 0, -209, 0, 0, 9993}, +{-211, 0, -211, 0, 0, 9993}, +{10743, 0, 10743, 0, 0, 9993}, +{42305, 0, 42305, 0, 0, 9993}, +{10749, 0, 10749, 0, 0, 9993}, +{-213, 0, -213, 0, 0, 9993}, +{-214, 0, -214, 0, 0, 9993}, +{10727, 0, 10727, 0, 0, 9993}, +{-218, 0, -218, 0, 0, 9993}, +{42307, 0, 42307, 0, 0, 9993}, +{42282, 0, 42282, 0, 0, 9993}, +{-69, 0, -69, 0, 0, 9993}, +{-217, 0, -217, 0, 0, 9993}, +{-71, 0, -71, 0, 0, 9993}, +{-219, 0, -219, 0, 0, 9993}, +{42261, 0, 42261, 0, 0, 9993}, +{42258, 0, 42258, 0, 0, 9993}, +{0, 0, 0, 0, 0, 14089}, +{0, 0, 0, 0, 0, 5889}, +{16777244, 17825818, 16777244, 0, 0, 30216}, +{0, 0, 0, 0, 0, 13321}, +{0, 116, 0, 0, 0, 10113}, +{0, 38, 0, 0, 0, 10113}, +{0, 37, 0, 0, 0, 10113}, +{0, 64, 0, 0, 0, 10113}, +{0, 63, 0, 0, 0, 10113}, +{50331681, 19922973, 50331681, 0, 0, 26377}, +{-38, 0, -38, 0, 0, 9993}, +{-37, 0, -37, 0, 0, 9993}, +{50331688, 19922980, 50331688, 0, 0, 26377}, +{16777261, 17825835, 16777261, 0, 0, 26377}, +{-64, 0, -64, 0, 0, 9993}, +{-63, 0, -63, 0, 0, 9993}, +{0, 8, 0, 0, 0, 10113}, +{16777264, 17825838, 16777264, 0, 0, 26377}, +{16777267, 17825841, 16777267, 0, 0, 26377}, +{0, 0, 0, 0, 0, 10113}, +{16777270, 17825844, 16777270, 0, 0, 26377}, +{16777273, 17825847, 16777273, 0, 0, 26377}, +{-8, 0, -8, 0, 0, 9993}, +{16777276, 17825850, 16777276, 0, 0, 26377}, +{16777279, 17825853, 16777279, 0, 0, 26377}, +{7, 0, 7, 0, 0, 9993}, +{-116, 0, -116, 0, 0, 9993}, +{0, -60, 0, 0, 0, 10113}, +{16777282, 17825856, 16777282, 0, 0, 26377}, +{0, -7, 0, 0, 0, 10113}, +{0, 80, 0, 0, 0, 10113}, +{-80, 0, -80, 0, 0, 9993}, +{0, 15, 0, 0, 0, 10113}, +{-15, 0, -15, 0, 0, 9993}, +{0, 48, 0, 0, 0, 10113}, +{-48, 0, -48, 0, 0, 9993}, +{33554502, 18874435, 33554504, 0, 0, 26377}, +{0, 0, 0, 0, 0, 1537}, +{0, 7264, 0, 0, 0, 10113}, +{3008, 0, 0, 0, 0, 9993}, +{0, 0, 0, 0, 1, 3588}, +{0, 0, 0, 0, 2, 3588}, +{0, 0, 0, 0, 3, 3588}, +{0, 0, 0, 0, 4, 3588}, +{0, 0, 0, 0, 5, 3588}, +{0, 0, 0, 0, 6, 3588}, +{0, 0, 0, 0, 7, 3588}, +{0, 0, 0, 0, 8, 3588}, +{0, 0, 0, 0, 9, 3588}, +{16777292, 17825866, 16777292, 0, 0, 26497}, +{16777295, 17825869, 16777295, 0, 0, 26497}, +{16777298, 17825872, 16777298, 0, 0, 26497}, +{16777301, 17825875, 16777301, 0, 0, 26497}, +{16777304, 17825878, 16777304, 0, 0, 26497}, +{16777307, 17825881, 16777307, 0, 0, 26497}, +{16777310, 17825884, 16777310, 0, 0, 26497}, +{16777313, 17825887, 16777313, 0, 0, 26497}, +{16777316, 17825890, 16777316, 0, 0, 26497}, +{16777319, 17825893, 16777319, 0, 0, 26497}, +{16777322, 17825896, 16777322, 0, 0, 26497}, +{16777325, 17825899, 16777325, 0, 0, 26497}, +{16777328, 17825902, 16777328, 0, 0, 26497}, +{16777331, 17825905, 16777331, 0, 0, 26497}, +{16777334, 17825908, 16777334, 0, 0, 26497}, +{16777337, 17825911, 16777337, 0, 0, 26497}, +{16777340, 17825914, 16777340, 0, 0, 26497}, +{16777343, 17825917, 16777343, 0, 0, 26497}, +{16777346, 17825920, 16777346, 0, 0, 26497}, +{16777349, 17825923, 16777349, 0, 0, 26497}, +{16777352, 17825926, 16777352, 0, 0, 26497}, +{16777355, 17825929, 16777355, 0, 0, 26497}, +{16777358, 17825932, 16777358, 0, 0, 26497}, +{16777361, 17825935, 16777361, 0, 0, 26497}, +{16777364, 17825938, 16777364, 0, 0, 26497}, +{16777367, 17825941, 16777367, 0, 0, 26497}, +{16777370, 17825944, 16777370, 0, 0, 26497}, +{16777373, 17825947, 16777373, 0, 0, 26497}, +{16777376, 17825950, 16777376, 0, 0, 26497}, +{16777379, 17825953, 16777379, 0, 0, 26497}, +{16777382, 17825956, 16777382, 0, 0, 26497}, +{16777385, 17825959, 16777385, 0, 0, 26497}, +{16777388, 17825962, 16777388, 0, 0, 26497}, +{16777391, 17825965, 16777391, 0, 0, 26497}, +{16777394, 17825968, 16777394, 0, 0, 26497}, +{16777397, 17825971, 16777397, 0, 0, 26497}, +{16777400, 17825974, 16777400, 0, 0, 26497}, +{16777403, 17825977, 16777403, 0, 0, 26497}, +{16777406, 17825980, 16777406, 0, 0, 26497}, +{16777409, 17825983, 16777409, 0, 0, 26497}, +{16777412, 17825986, 16777412, 0, 0, 26497}, +{16777415, 17825989, 16777415, 0, 0, 26497}, +{16777418, 17825992, 16777418, 0, 0, 26497}, +{16777421, 17825995, 16777421, 0, 0, 26497}, +{16777424, 17825998, 16777424, 0, 0, 26497}, +{16777427, 17826001, 16777427, 0, 0, 26497}, +{16777430, 17826004, 16777430, 0, 0, 26497}, +{16777433, 17826007, 16777433, 0, 0, 26497}, +{16777436, 17826010, 16777436, 0, 0, 26497}, +{16777439, 17826013, 16777439, 0, 0, 26497}, +{16777442, 17826016, 16777442, 0, 0, 26497}, +{16777445, 17826019, 16777445, 0, 0, 26497}, +{16777448, 17826022, 16777448, 0, 0, 26497}, +{16777451, 17826025, 16777451, 0, 0, 26497}, +{16777454, 17826028, 16777454, 0, 0, 26497}, +{16777457, 17826031, 16777457, 0, 0, 26497}, +{16777460, 17826034, 16777460, 0, 0, 26497}, +{16777463, 17826037, 16777463, 0, 0, 26497}, +{16777466, 17826040, 16777466, 0, 0, 26497}, +{16777469, 17826043, 16777469, 0, 0, 26497}, +{16777472, 17826046, 16777472, 0, 0, 26497}, +{16777475, 17826049, 16777475, 0, 0, 26497}, +{16777478, 17826052, 16777478, 0, 0, 26497}, +{16777481, 17826055, 16777481, 0, 0, 26497}, +{16777484, 17826058, 16777484, 0, 0, 26497}, +{16777487, 17826061, 16777487, 0, 0, 26497}, +{16777490, 17826064, 16777490, 0, 0, 26497}, +{16777493, 17826067, 16777493, 0, 0, 26497}, +{16777496, 17826070, 16777496, 0, 0, 26497}, +{16777499, 17826073, 16777499, 0, 0, 26497}, +{16777502, 17826076, 16777502, 0, 0, 26497}, +{16777505, 17826079, 16777505, 0, 0, 26497}, +{16777508, 17826082, 16777508, 0, 0, 26497}, +{16777511, 17826085, 16777511, 0, 0, 26497}, +{16777514, 17826088, 16777514, 0, 0, 26497}, +{16777517, 17826091, 16777517, 0, 0, 26497}, +{16777520, 17826094, 16777520, 0, 0, 26497}, +{16777523, 17826097, 16777523, 0, 0, 26497}, +{16777526, 17826100, 16777526, 0, 0, 26497}, +{16777529, 17826103, 16777529, 0, 0, 26497}, +{16777532, 17826106, 16777532, 0, 0, 26497}, +{16777535, 17826109, 16777535, 0, 0, 26497}, +{16777538, 17826112, 16777538, 0, 0, 26497}, +{16777541, 17826115, 16777541, 0, 0, 26497}, +{16777544, 17826118, 16777544, 0, 0, 26497}, +{16777547, 17826121, 16777547, 0, 0, 26497}, +{16777550, 17826124, 16777550, 0, 0, 26377}, +{16777553, 17826127, 16777553, 0, 0, 26377}, +{16777556, 17826130, 16777556, 0, 0, 26377}, +{16777559, 17826133, 16777559, 0, 0, 26377}, +{16777562, 17826136, 16777562, 0, 0, 26377}, +{16777565, 17826139, 16777565, 0, 0, 26377}, +{0, 0, 0, 0, 0, 3840}, +{0, 0, 0, 0, 0, 5888}, +{16777568, 17826142, 16777568, 0, 0, 26377}, +{16777571, 17826145, 16777571, 0, 0, 26377}, +{16777574, 17826148, 16777574, 0, 0, 26377}, +{16777577, 17826151, 16777577, 0, 0, 26377}, +{16777580, 17826154, 16777580, 0, 0, 26377}, +{16777583, 17826157, 16777583, 0, 0, 26377}, +{16777586, 17826160, 16777586, 0, 0, 26377}, +{16777589, 17826163, 16777589, 0, 0, 26377}, +{16777592, 17826166, 16777592, 0, 0, 26377}, +{0, -3008, 0, 0, 0, 10113}, +{35332, 0, 35332, 0, 0, 9993}, +{3814, 0, 3814, 0, 0, 9993}, +{35384, 0, 35384, 0, 0, 9993}, +{33554812, 18874745, 33554812, 0, 0, 26377}, +{33554817, 18874750, 33554817, 0, 0, 26377}, +{33554822, 18874755, 33554822, 0, 0, 26377}, +{33554827, 18874760, 33554827, 0, 0, 26377}, +{33554832, 18874765, 33554832, 0, 0, 26377}, +{16777620, 17826194, 16777620, 0, 0, 26377}, +{16777624, 18874773, 16777624, 0, 0, 26497}, +{8, 0, 8, 0, 0, 9993}, +{0, -8, 0, 0, 0, 10113}, +{33554844, 18874777, 33554844, 0, 0, 26377}, +{50332066, 19923358, 50332066, 0, 0, 26377}, +{50332073, 19923365, 50332073, 0, 0, 26377}, +{50332080, 19923372, 50332080, 0, 0, 26377}, +{74, 0, 74, 0, 0, 9993}, +{86, 0, 86, 0, 0, 9993}, +{100, 0, 100, 0, 0, 9993}, +{128, 0, 128, 0, 0, 9993}, +{112, 0, 112, 0, 0, 9993}, +{126, 0, 126, 0, 0, 9993}, +{33554870, 18874803, 16777656, 0, 0, 26377}, +{33554876, 18874809, 16777662, 0, 0, 26377}, +{33554882, 18874815, 16777668, 0, 0, 26377}, +{33554888, 18874821, 16777674, 0, 0, 26377}, +{33554894, 18874827, 16777680, 0, 0, 26377}, +{33554900, 18874833, 16777686, 0, 0, 26377}, +{33554906, 18874839, 16777692, 0, 0, 26377}, +{33554912, 18874845, 16777698, 0, 0, 26377}, +{33554918, 18874851, 16777704, 0, 0, 26433}, +{33554924, 18874857, 16777710, 0, 0, 26433}, +{33554930, 18874863, 16777716, 0, 0, 26433}, +{33554936, 18874869, 16777722, 0, 0, 26433}, +{33554942, 18874875, 16777728, 0, 0, 26433}, +{33554948, 18874881, 16777734, 0, 0, 26433}, +{33554954, 18874887, 16777740, 0, 0, 26433}, +{33554960, 18874893, 16777746, 0, 0, 26433}, +{33554966, 18874899, 16777752, 0, 0, 26377}, +{33554972, 18874905, 16777758, 0, 0, 26377}, +{33554978, 18874911, 16777764, 0, 0, 26377}, +{33554984, 18874917, 16777770, 0, 0, 26377}, +{33554990, 18874923, 16777776, 0, 0, 26377}, +{33554996, 18874929, 16777782, 0, 0, 26377}, +{33555002, 18874935, 16777788, 0, 0, 26377}, +{33555008, 18874941, 16777794, 0, 0, 26377}, +{33555014, 18874947, 16777800, 0, 0, 26433}, +{33555020, 18874953, 16777806, 0, 0, 26433}, +{33555026, 18874959, 16777812, 0, 0, 26433}, +{33555032, 18874965, 16777818, 0, 0, 26433}, +{33555038, 18874971, 16777824, 0, 0, 26433}, +{33555044, 18874977, 16777830, 0, 0, 26433}, +{33555050, 18874983, 16777836, 0, 0, 26433}, +{33555056, 18874989, 16777842, 0, 0, 26433}, +{33555062, 18874995, 16777848, 0, 0, 26377}, +{33555068, 18875001, 16777854, 0, 0, 26377}, +{33555074, 18875007, 16777860, 0, 0, 26377}, +{33555080, 18875013, 16777866, 0, 0, 26377}, +{33555086, 18875019, 16777872, 0, 0, 26377}, +{33555092, 18875025, 16777878, 0, 0, 26377}, +{33555098, 18875031, 16777884, 0, 0, 26377}, +{33555104, 18875037, 16777890, 0, 0, 26377}, +{33555110, 18875043, 16777896, 0, 0, 26433}, +{33555116, 18875049, 16777902, 0, 0, 26433}, +{33555122, 18875055, 16777908, 0, 0, 26433}, +{33555128, 18875061, 16777914, 0, 0, 26433}, +{33555134, 18875067, 16777920, 0, 0, 26433}, +{33555140, 18875073, 16777926, 0, 0, 26433}, +{33555146, 18875079, 16777932, 0, 0, 26433}, +{33555152, 18875085, 16777938, 0, 0, 26433}, +{33555158, 18875091, 33555160, 0, 0, 26377}, +{33555165, 18875098, 16777951, 0, 0, 26377}, +{33555171, 18875104, 33555173, 0, 0, 26377}, +{33555178, 18875111, 33555178, 0, 0, 26377}, +{50332400, 19923692, 50332403, 0, 0, 26377}, +{0, -74, 0, 0, 0, 10113}, +{33555193, 18875126, 16777979, 0, 0, 26433}, +{16777982, 17826556, 16777982, 0, 0, 26377}, +{33555202, 18875135, 33555204, 0, 0, 26377}, +{33555209, 18875142, 16777995, 0, 0, 26377}, +{33555215, 18875148, 33555217, 0, 0, 26377}, +{33555222, 18875155, 33555222, 0, 0, 26377}, +{50332444, 19923736, 50332447, 0, 0, 26377}, +{0, -86, 0, 0, 0, 10113}, +{33555237, 18875170, 16778023, 0, 0, 26433}, +{50332460, 19923752, 50332460, 0, 0, 26377}, +{50332467, 19923759, 50332467, 0, 0, 26377}, +{33555257, 18875190, 33555257, 0, 0, 26377}, +{50332479, 19923771, 50332479, 0, 0, 26377}, +{0, -100, 0, 0, 0, 10113}, +{50332486, 19923778, 50332486, 0, 0, 26377}, +{50332493, 19923785, 50332493, 0, 0, 26377}, +{33555283, 18875216, 33555283, 0, 0, 26377}, +{33555288, 18875221, 33555288, 0, 0, 26377}, +{50332510, 19923802, 50332510, 0, 0, 26377}, +{0, -112, 0, 0, 0, 10113}, +{33555300, 18875233, 33555302, 0, 0, 26377}, +{33555307, 18875240, 16778093, 0, 0, 26377}, +{33555313, 18875246, 33555315, 0, 0, 26377}, +{33555320, 18875253, 33555320, 0, 0, 26377}, +{50332542, 19923834, 50332545, 0, 0, 26377}, +{0, -128, 0, 0, 0, 10113}, +{0, -126, 0, 0, 0, 10113}, +{33555335, 18875268, 16778121, 0, 0, 26433}, +{0, 0, 0, 0, 0, 4608}, +{0, 0, 0, 0, 0, 3076}, +{0, 0, 0, 0, 4, 3076}, +{0, 0, 0, 0, 5, 3076}, +{0, 0, 0, 0, 6, 3076}, +{0, 0, 0, 0, 7, 3076}, +{0, 0, 0, 0, 8, 3076}, +{0, 0, 0, 0, 9, 3076}, +{0, 0, 0, 0, 0, 1792}, +{0, -7517, 0, 0, 0, 10113}, +{0, -8383, 0, 0, 0, 10113}, +{0, -8262, 0, 0, 0, 10113}, +{0, 28, 0, 0, 0, 10113}, +{-28, 0, -28, 0, 0, 9993}, +{0, 16, 0, 0, 0, 12160}, +{-16, 0, -16, 0, 0, 12040}, +{0, 26, 0, 0, 0, 9344}, +{-26, 0, -26, 0, 0, 9224}, +{0, -10743, 0, 0, 0, 10113}, +{0, -3814, 0, 0, 0, 10113}, +{0, -10727, 0, 0, 0, 10113}, +{-10795, 0, -10795, 0, 0, 9993}, +{-10792, 0, -10792, 0, 0, 9993}, +{0, -10780, 0, 0, 0, 10113}, +{0, -10749, 0, 0, 0, 10113}, +{0, -10783, 0, 0, 0, 10113}, +{0, -10782, 0, 0, 0, 10113}, +{0, -10815, 0, 0, 0, 10113}, +{-7264, 0, -7264, 0, 0, 9993}, +{0, 0, 0, 0, 0, 5121}, +{0, 0, 0, 0, 0, 3841}, +{0, -35332, 0, 0, 0, 10113}, +{0, -42280, 0, 0, 0, 10113}, +{48, 0, 48, 0, 0, 9993}, +{0, -42308, 0, 0, 0, 10113}, +{0, -42319, 0, 0, 0, 10113}, +{0, -42315, 0, 0, 0, 10113}, +{0, -42305, 0, 0, 0, 10113}, +{0, -42258, 0, 0, 0, 10113}, +{0, -42282, 0, 0, 0, 10113}, +{0, -42261, 0, 0, 0, 10113}, +{0, 928, 0, 0, 0, 10113}, +{0, -48, 0, 0, 0, 10113}, +{0, -42307, 0, 0, 0, 10113}, +{0, -35384, 0, 0, 0, 10113}, +{0, -42343, 0, 0, 0, 10113}, +{0, -42561, 0, 0, 0, 10113}, +{-928, 0, -928, 0, 0, 9993}, +{16778124, 17826698, 16778124, 0, 0, 26377}, +{16778127, 17826701, 16778127, 0, 0, 26377}, +{16778130, 17826704, 16778130, 0, 0, 26377}, +{16778133, 17826707, 16778133, 0, 0, 26377}, +{16778136, 17826710, 16778136, 0, 0, 26377}, +{16778139, 17826713, 16778139, 0, 0, 26377}, +{16778142, 17826716, 16778142, 0, 0, 26377}, +{16778145, 17826719, 16778145, 0, 0, 26377}, +{16778148, 17826722, 16778148, 0, 0, 26377}, +{16778151, 17826725, 16778151, 0, 0, 26377}, +{16778154, 17826728, 16778154, 0, 0, 26377}, +{16778157, 17826731, 16778157, 0, 0, 26377}, +{16778160, 17826734, 16778160, 0, 0, 26377}, +{16778163, 17826737, 16778163, 0, 0, 26377}, +{16778166, 17826740, 16778166, 0, 0, 26377}, +{16778169, 17826743, 16778169, 0, 0, 26377}, +{16778172, 17826746, 16778172, 0, 0, 26377}, +{16778175, 17826749, 16778175, 0, 0, 26377}, +{16778178, 17826752, 16778178, 0, 0, 26377}, +{16778181, 17826755, 16778181, 0, 0, 26377}, +{16778184, 17826758, 16778184, 0, 0, 26377}, +{16778187, 17826761, 16778187, 0, 0, 26377}, +{16778190, 17826764, 16778190, 0, 0, 26377}, +{16778193, 17826767, 16778193, 0, 0, 26377}, +{16778196, 17826770, 16778196, 0, 0, 26377}, +{16778199, 17826773, 16778199, 0, 0, 26377}, +{16778202, 17826776, 16778202, 0, 0, 26377}, +{16778205, 17826779, 16778205, 0, 0, 26377}, +{16778208, 17826782, 16778208, 0, 0, 26377}, +{16778211, 17826785, 16778211, 0, 0, 26377}, +{16778214, 17826788, 16778214, 0, 0, 26377}, +{16778217, 17826791, 16778217, 0, 0, 26377}, +{16778220, 17826794, 16778220, 0, 0, 26377}, +{16778223, 17826797, 16778223, 0, 0, 26377}, +{16778226, 17826800, 16778226, 0, 0, 26377}, +{16778229, 17826803, 16778229, 0, 0, 26377}, +{16778232, 17826806, 16778232, 0, 0, 26377}, +{16778235, 17826809, 16778235, 0, 0, 26377}, +{16778238, 17826812, 16778238, 0, 0, 26377}, +{16778241, 17826815, 16778241, 0, 0, 26377}, +{16778244, 17826818, 16778244, 0, 0, 26377}, +{16778247, 17826821, 16778247, 0, 0, 26377}, +{16778250, 17826824, 16778250, 0, 0, 26377}, +{16778253, 17826827, 16778253, 0, 0, 26377}, +{16778256, 17826830, 16778256, 0, 0, 26377}, +{16778259, 17826833, 16778259, 0, 0, 26377}, +{16778262, 17826836, 16778262, 0, 0, 26377}, +{16778265, 17826839, 16778265, 0, 0, 26377}, +{16778268, 17826842, 16778268, 0, 0, 26377}, +{16778271, 17826845, 16778271, 0, 0, 26377}, +{16778274, 17826848, 16778274, 0, 0, 26377}, +{16778277, 17826851, 16778277, 0, 0, 26377}, +{16778280, 17826854, 16778280, 0, 0, 26377}, +{16778283, 17826857, 16778283, 0, 0, 26377}, +{16778286, 17826860, 16778286, 0, 0, 26377}, +{16778289, 17826863, 16778289, 0, 0, 26377}, +{16778292, 17826866, 16778292, 0, 0, 26377}, +{16778295, 17826869, 16778295, 0, 0, 26377}, +{16778298, 17826872, 16778298, 0, 0, 26377}, +{16778301, 17826875, 16778301, 0, 0, 26377}, +{16778304, 17826878, 16778304, 0, 0, 26377}, +{16778307, 17826881, 16778307, 0, 0, 26377}, +{16778310, 17826884, 16778310, 0, 0, 26377}, +{16778313, 17826887, 16778313, 0, 0, 26377}, +{16778316, 17826890, 16778316, 0, 0, 26377}, +{16778319, 17826893, 16778319, 0, 0, 26377}, +{16778322, 17826896, 16778322, 0, 0, 26377}, +{16778325, 17826899, 16778325, 0, 0, 26377}, +{16778328, 17826902, 16778328, 0, 0, 26377}, +{16778331, 17826905, 16778331, 0, 0, 26377}, +{16778334, 17826908, 16778334, 0, 0, 26377}, +{16778337, 17826911, 16778337, 0, 0, 26377}, +{16778340, 17826914, 16778340, 0, 0, 26377}, +{16778343, 17826917, 16778343, 0, 0, 26377}, +{16778346, 17826920, 16778346, 0, 0, 26377}, +{16778349, 17826923, 16778349, 0, 0, 26377}, +{16778352, 17826926, 16778352, 0, 0, 26377}, +{16778355, 17826929, 16778355, 0, 0, 26377}, +{16778358, 17826932, 16778358, 0, 0, 26377}, +{16778361, 17826935, 16778361, 0, 0, 26377}, +{33555581, 18875514, 33555583, 0, 0, 26377}, +{33555588, 18875521, 33555590, 0, 0, 26377}, +{33555595, 18875528, 33555597, 0, 0, 26377}, +{50332819, 19924111, 50332822, 0, 0, 26377}, +{50332829, 19924121, 50332832, 0, 0, 26377}, +{33555622, 18875555, 33555624, 0, 0, 26377}, +{33555629, 18875562, 33555631, 0, 0, 26377}, +{33555636, 18875569, 33555638, 0, 0, 26377}, +{33555643, 18875576, 33555645, 0, 0, 26377}, +{33555650, 18875583, 33555652, 0, 0, 26377}, +{33555657, 18875590, 33555659, 0, 0, 26377}, +{33555664, 18875597, 33555666, 0, 0, 26377}, +{0, 0, 0, 0, 0, 1025}, +{0, 0, 0, 0, 0, 5633}, +{0, 40, 0, 0, 0, 10113}, +{-40, 0, -40, 0, 0, 9993}, +{0, 39, 0, 0, 0, 10113}, +{-39, 0, -39, 0, 0, 9993}, +{0, 27, 0, 0, 0, 10113}, +{-27, 0, -27, 0, 0, 9993}, +{0, 34, 0, 0, 0, 10113}, +{-34, 0, -34, 0, 0, 9993}, +{0, 0, 0, 0, 0, 9344}, +}; +/* extended case mappings */ +const Py_UCS4 _PyUnicode_ExtendedCase[] = { +181, +956, +924, +223, +115, +115, +83, +83, +83, +115, +105, +775, +304, +329, +700, +110, +700, +78, +383, +115, +83, +496, +106, +780, +74, +780, +837, +953, +921, +912, +953, +776, +769, +921, +776, +769, +944, +965, +776, +769, +933, +776, +769, +962, +963, +931, +976, +946, +914, +977, +952, +920, +981, +966, +934, +982, +960, +928, +1008, +954, +922, +1009, +961, +929, +1013, +949, +917, +1415, +1381, +1410, +1333, +1362, +1333, +1410, +43888, +5024, +5024, +43889, +5025, +5025, +43890, +5026, +5026, +43891, +5027, +5027, +43892, +5028, +5028, +43893, +5029, +5029, +43894, +5030, +5030, +43895, +5031, +5031, +43896, +5032, +5032, +43897, +5033, +5033, +43898, +5034, +5034, +43899, +5035, +5035, +43900, +5036, +5036, +43901, +5037, +5037, +43902, +5038, +5038, +43903, +5039, +5039, +43904, +5040, +5040, +43905, +5041, +5041, +43906, +5042, +5042, +43907, +5043, +5043, +43908, +5044, +5044, +43909, +5045, +5045, +43910, +5046, +5046, +43911, +5047, +5047, +43912, +5048, +5048, +43913, +5049, +5049, +43914, +5050, +5050, +43915, +5051, +5051, +43916, +5052, +5052, +43917, +5053, +5053, +43918, +5054, +5054, +43919, +5055, +5055, +43920, +5056, +5056, +43921, +5057, +5057, +43922, +5058, +5058, +43923, +5059, +5059, +43924, +5060, +5060, +43925, +5061, +5061, +43926, +5062, +5062, +43927, +5063, +5063, +43928, +5064, +5064, +43929, +5065, +5065, +43930, +5066, +5066, +43931, +5067, +5067, +43932, +5068, +5068, +43933, +5069, +5069, +43934, +5070, +5070, +43935, +5071, +5071, +43936, +5072, +5072, +43937, +5073, +5073, +43938, +5074, +5074, +43939, +5075, +5075, +43940, +5076, +5076, +43941, +5077, +5077, +43942, +5078, +5078, +43943, +5079, +5079, +43944, +5080, +5080, +43945, +5081, +5081, +43946, +5082, +5082, +43947, +5083, +5083, +43948, +5084, +5084, +43949, +5085, +5085, +43950, +5086, +5086, +43951, +5087, +5087, +43952, +5088, +5088, +43953, +5089, +5089, +43954, +5090, +5090, +43955, +5091, +5091, +43956, +5092, +5092, +43957, +5093, +5093, +43958, +5094, +5094, +43959, +5095, +5095, +43960, +5096, +5096, +43961, +5097, +5097, +43962, +5098, +5098, +43963, +5099, +5099, +43964, +5100, +5100, +43965, +5101, +5101, +43966, +5102, +5102, +43967, +5103, +5103, +5112, +5104, +5104, +5113, +5105, +5105, +5114, +5106, +5106, +5115, +5107, +5107, +5116, +5108, +5108, +5117, +5109, +5109, +5112, +5104, +5104, +5113, +5105, +5105, +5114, +5106, +5106, +5115, +5107, +5107, +5116, +5108, +5108, +5117, +5109, +5109, +7296, +1074, +1042, +7297, +1076, +1044, +7298, +1086, +1054, +7299, +1089, +1057, +7300, +1090, +1058, +7301, +1090, +1058, +7302, +1098, +1066, +7303, +1123, +1122, +7304, +42571, +42570, +7830, +104, +817, +72, +817, +7831, +116, +776, +84, +776, +7832, +119, +778, +87, +778, +7833, +121, +778, +89, +778, +7834, +97, +702, +65, +702, +7835, +7777, +7776, +223, +115, +115, +7838, +8016, +965, +787, +933, +787, +8018, +965, +787, +768, +933, +787, +768, +8020, +965, +787, +769, +933, +787, +769, +8022, +965, +787, +834, +933, +787, +834, +8064, +7936, +953, +7944, +921, +8072, +8065, +7937, +953, +7945, +921, +8073, +8066, +7938, +953, +7946, +921, +8074, +8067, +7939, +953, +7947, +921, +8075, +8068, +7940, +953, +7948, +921, +8076, +8069, +7941, +953, +7949, +921, +8077, +8070, +7942, +953, +7950, +921, +8078, +8071, +7943, +953, +7951, +921, +8079, +8064, +7936, +953, +7944, +921, +8072, +8065, +7937, +953, +7945, +921, +8073, +8066, +7938, +953, +7946, +921, +8074, +8067, +7939, +953, +7947, +921, +8075, +8068, +7940, +953, +7948, +921, +8076, +8069, +7941, +953, +7949, +921, +8077, +8070, +7942, +953, +7950, +921, +8078, +8071, +7943, +953, +7951, +921, +8079, +8080, +7968, +953, +7976, +921, +8088, +8081, +7969, +953, +7977, +921, +8089, +8082, +7970, +953, +7978, +921, +8090, +8083, +7971, +953, +7979, +921, +8091, +8084, +7972, +953, +7980, +921, +8092, +8085, +7973, +953, +7981, +921, +8093, +8086, +7974, +953, +7982, +921, +8094, +8087, +7975, +953, +7983, +921, +8095, +8080, +7968, +953, +7976, +921, +8088, +8081, +7969, +953, +7977, +921, +8089, +8082, +7970, +953, +7978, +921, +8090, +8083, +7971, +953, +7979, +921, +8091, +8084, +7972, +953, +7980, +921, +8092, +8085, +7973, +953, +7981, +921, +8093, +8086, +7974, +953, +7982, +921, +8094, +8087, +7975, +953, +7983, +921, +8095, +8096, +8032, +953, +8040, +921, +8104, +8097, +8033, +953, +8041, +921, +8105, +8098, +8034, +953, +8042, +921, +8106, +8099, +8035, +953, +8043, +921, +8107, +8100, +8036, +953, +8044, +921, +8108, +8101, +8037, +953, +8045, +921, +8109, +8102, +8038, +953, +8046, +921, +8110, +8103, +8039, +953, +8047, +921, +8111, +8096, +8032, +953, +8040, +921, +8104, +8097, +8033, +953, +8041, +921, +8105, +8098, +8034, +953, +8042, +921, +8106, +8099, +8035, +953, +8043, +921, +8107, +8100, +8036, +953, +8044, +921, +8108, +8101, +8037, +953, +8045, +921, +8109, +8102, +8038, +953, +8046, +921, +8110, +8103, +8039, +953, +8047, +921, +8111, +8114, +8048, +953, +8122, +921, +8122, +837, +8115, +945, +953, +913, +921, +8124, +8116, +940, +953, +902, +921, +902, +837, +8118, +945, +834, +913, +834, +8119, +945, +834, +953, +913, +834, +921, +913, +834, +837, +8115, +945, +953, +913, +921, +8124, +8126, +953, +921, +8130, +8052, +953, +8138, +921, +8138, +837, +8131, +951, +953, +919, +921, +8140, +8132, +942, +953, +905, +921, +905, +837, +8134, +951, +834, +919, +834, +8135, +951, +834, +953, +919, +834, +921, +919, +834, +837, +8131, +951, +953, +919, +921, +8140, +8146, +953, +776, +768, +921, +776, +768, +8147, +953, +776, +769, +921, +776, +769, +8150, +953, +834, +921, +834, +8151, +953, +776, +834, +921, +776, +834, +8162, +965, +776, +768, +933, +776, +768, +8163, +965, +776, +769, +933, +776, +769, +8164, +961, +787, +929, +787, +8166, +965, +834, +933, +834, +8167, +965, +776, +834, +933, +776, +834, +8178, +8060, +953, +8186, +921, +8186, +837, +8179, +969, +953, +937, +921, +8188, +8180, +974, +953, +911, +921, +911, +837, +8182, +969, +834, +937, +834, +8183, +969, +834, +953, +937, +834, +921, +937, +834, +837, +8179, +969, +953, +937, +921, +8188, +43888, +5024, +5024, +43889, +5025, +5025, +43890, +5026, +5026, +43891, +5027, +5027, +43892, +5028, +5028, +43893, +5029, +5029, +43894, +5030, +5030, +43895, +5031, +5031, +43896, +5032, +5032, +43897, +5033, +5033, +43898, +5034, +5034, +43899, +5035, +5035, +43900, +5036, +5036, +43901, +5037, +5037, +43902, +5038, +5038, +43903, +5039, +5039, +43904, +5040, +5040, +43905, +5041, +5041, +43906, +5042, +5042, +43907, +5043, +5043, +43908, +5044, +5044, +43909, +5045, +5045, +43910, +5046, +5046, +43911, +5047, +5047, +43912, +5048, +5048, +43913, +5049, +5049, +43914, +5050, +5050, +43915, +5051, +5051, +43916, +5052, +5052, +43917, +5053, +5053, +43918, +5054, +5054, +43919, +5055, +5055, +43920, +5056, +5056, +43921, +5057, +5057, +43922, +5058, +5058, +43923, +5059, +5059, +43924, +5060, +5060, +43925, +5061, +5061, +43926, +5062, +5062, +43927, +5063, +5063, +43928, +5064, +5064, +43929, +5065, +5065, +43930, +5066, +5066, +43931, +5067, +5067, +43932, +5068, +5068, +43933, +5069, +5069, +43934, +5070, +5070, +43935, +5071, +5071, +43936, +5072, +5072, +43937, +5073, +5073, +43938, +5074, +5074, +43939, +5075, +5075, +43940, +5076, +5076, +43941, +5077, +5077, +43942, +5078, +5078, +43943, +5079, +5079, +43944, +5080, +5080, +43945, +5081, +5081, +43946, +5082, +5082, +43947, +5083, +5083, +43948, +5084, +5084, +43949, +5085, +5085, +43950, +5086, +5086, +43951, +5087, +5087, +43952, +5088, +5088, +43953, +5089, +5089, +43954, +5090, +5090, +43955, +5091, +5091, +43956, +5092, +5092, +43957, +5093, +5093, +43958, +5094, +5094, +43959, +5095, +5095, +43960, +5096, +5096, +43961, +5097, +5097, +43962, +5098, +5098, +43963, +5099, +5099, +43964, +5100, +5100, +43965, +5101, +5101, +43966, +5102, +5102, +43967, +5103, +5103, +64256, +102, +102, +70, +70, +70, +102, +64257, +102, +105, +70, +73, +70, +105, +64258, +102, +108, +70, +76, +70, +108, +64259, +102, +102, +105, +70, +70, +73, +70, +102, +105, +64260, +102, +102, +108, +70, +70, +76, +70, +102, +108, +64261, +115, +116, +83, +84, +83, +116, +64262, +115, +116, +83, +84, +83, +116, +64275, +1396, +1398, +1348, +1350, +1348, +1398, +64276, +1396, +1381, +1348, +1333, +1348, +1381, +64277, +1396, +1387, +1348, +1339, +1348, +1387, +64278, +1406, +1398, +1358, +1350, +1358, +1398, +64279, +1396, +1389, +1348, +1341, +1348, +1389, +}; +/* type indexes */ +#define SHIFT 7 +static const unsigned short index1[] = { +0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, +21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 34, 35, 36, 37, +38, 39, 34, 34, 34, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, +53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 64, 64, 64, 65, 66, 64, +64, 64, 64, 67, 68, 64, 64, 64, 64, 64, 64, 69, 64, 70, 71, 72, 73, 74, +75, 64, 76, 77, 78, 79, 80, 81, 82, 64, 64, 83, 84, 34, 34, 34, 34, 34, +34, 85, 34, 34, 34, 34, 34, 86, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, +34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, +34, 34, 34, 34, 34, 34, 34, 34, 87, 88, 89, 90, 91, 92, 34, 93, 34, 34, +34, 94, 95, 34, 34, 34, 34, 34, 96, 34, 34, 34, 97, 34, 34, 34, 34, 34, +34, 34, 34, 34, 34, 98, 99, 100, 34, 34, 34, 34, 34, 34, 101, 102, 34, +34, 34, 34, 34, 34, 34, 34, 103, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, +104, 34, 34, 34, 92, 34, 34, 34, 34, 34, 34, 34, 34, 105, 34, 34, 34, 34, +106, 107, 34, 34, 34, 34, 34, 108, 34, 34, 34, 34, 34, 34, 34, 34, 34, +34, 34, 34, 34, 92, 34, 34, 34, 34, 34, 34, 109, 34, 34, 34, 34, 34, 34, +34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 110, 111, 34, 34, 34, 34, 34, 34, +34, 34, 34, 112, 34, 34, 34, 34, 113, 34, 34, 114, 115, 34, 34, 34, 34, +34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 116, 34, 34, 34, +34, 34, 34, 34, 34, 117, 34, 34, 118, 119, 120, 121, 122, 123, 124, 125, +126, 127, 128, 129, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, +34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, +34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, +34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, +34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, +34, 34, 130, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 132, 133, +134, 135, 136, 137, 138, 34, 139, 140, 141, 142, 143, 144, 145, 146, 147, +148, 131, 149, 150, 151, 152, 153, 154, 155, 34, 34, 156, 157, 158, 159, +160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, +174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 131, 184, 185, 186, +187, 131, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, +131, 200, 201, 202, 203, 34, 34, 34, 204, 34, 205, 206, 207, 34, 208, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 209, 34, 34, 34, 34, 34, 34, 34, 34, 210, +34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, +34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 146, 34, 34, 34, 34, 211, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 212, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 34, 34, 34, 34, +213, 214, 215, 216, 131, 131, 217, 131, 218, 219, 220, 221, 34, 34, 34, +34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, +34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, +34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, +222, 223, 224, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +225, 34, 34, 226, 34, 34, 227, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 228, 229, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 64, +230, 64, 64, 64, 231, 232, 233, 64, 234, 235, 236, 237, 238, 239, 131, +240, 241, 242, 243, 244, 245, 246, 247, 64, 64, 64, 64, 248, 249, 131, +131, 131, 131, 131, 131, 131, 131, 250, 131, 251, 252, 253, 131, 131, +254, 131, 131, 131, 255, 131, 256, 131, 257, 131, 258, 34, 259, 260, 131, +131, 131, 131, 131, 261, 262, 263, 131, 264, 265, 131, 131, 266, 267, +268, 269, 270, 131, 64, 271, 64, 64, 64, 64, 64, 272, 64, 273, 274, 275, +64, 64, 276, 277, 64, 278, 131, 131, 131, 131, 131, 131, 131, 131, 279, +280, 281, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 85, +282, 34, 283, 284, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, +34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, +34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 285, +34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 286, 34, 34, 34, 34, 34, 34, +34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, +34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 287, 34, 34, 34, 34, 34, 34, 34, +34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, +34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, +34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, +34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 108, 34, +34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, +34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, +34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, +34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, +34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, +34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, +34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, +34, 34, 34, 34, 34, 34, 34, 34, 34, 288, 34, 34, 34, 34, 34, 34, 34, 34, +34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, +34, 34, 34, 34, 34, 34, 34, 34, 289, 34, 34, 34, 34, 34, 34, 34, 34, 34, +34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, +34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 290, +34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, +34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, +34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, +34, 34, 34, 291, 34, 34, 34, 34, 292, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 34, 285, 34, +34, 293, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 34, 34, +34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, +34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, +294, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, +34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, +34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, +34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 295, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 296, 131, 297, 298, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, +131, 131, 131, +}; +static const unsigned short index2[] = { +0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 2, 2, 2, 1, 3, 4, 4, 4, 4, 4, 4, 5, 4, 4, 4, 4, 4, 4, 5, 4, +6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 5, 4, 4, 4, 4, 4, 4, 16, 16, 16, 16, +16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, +16, 16, 16, 16, 4, 4, 4, 5, 17, 5, 18, 18, 18, 18, 18, 18, 18, 18, 18, +18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 4, 4, +4, 4, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 4, 4, 4, 4, 4, 4, 4, 5, 4, 19, 4, 4, +20, 4, 5, 4, 4, 21, 22, 5, 23, 4, 24, 5, 25, 19, 4, 26, 26, 26, 4, 16, +16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, +16, 16, 16, 16, 4, 16, 16, 16, 16, 16, 16, 16, 27, 18, 18, 18, 18, 18, +18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, +4, 18, 18, 18, 18, 18, 18, 18, 28, 29, 30, 29, 30, 29, 30, 29, 30, 29, +30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, +30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, +30, 29, 30, 31, 32, 29, 30, 29, 30, 29, 30, 19, 29, 30, 29, 30, 29, 30, +29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 33, 29, 30, 29, 30, 29, 30, 29, +30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, +30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, +30, 29, 30, 34, 29, 30, 29, 30, 29, 30, 35, 36, 37, 29, 30, 29, 30, 38, +29, 30, 39, 39, 29, 30, 19, 40, 41, 42, 29, 30, 39, 43, 44, 45, 46, 29, +30, 47, 48, 45, 49, 50, 51, 29, 30, 29, 30, 29, 30, 52, 29, 30, 52, 19, +19, 29, 30, 52, 29, 30, 53, 53, 29, 30, 29, 30, 54, 29, 30, 19, 55, 29, +30, 19, 56, 55, 55, 55, 55, 57, 58, 59, 57, 58, 59, 57, 58, 59, 29, 30, +29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 60, 29, 30, 29, +30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 61, 57, 58, +59, 29, 30, 62, 63, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, +30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, +30, 29, 30, 29, 30, 29, 30, 29, 30, 64, 19, 29, 30, 29, 30, 29, 30, 29, +30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 19, 19, 19, 19, 19, 19, 65, +29, 30, 66, 67, 68, 68, 29, 30, 69, 70, 71, 29, 30, 29, 30, 29, 30, 29, +30, 29, 30, 72, 73, 74, 75, 76, 19, 77, 77, 19, 78, 19, 79, 80, 19, 19, +19, 77, 81, 19, 82, 83, 84, 85, 19, 86, 87, 85, 88, 89, 19, 19, 87, 19, +90, 91, 19, 19, 92, 19, 19, 19, 19, 19, 19, 19, 93, 19, 19, 94, 19, 95, +94, 19, 19, 19, 96, 94, 97, 98, 98, 99, 19, 19, 19, 19, 19, 100, 19, 55, +55, 19, 19, 19, 19, 19, 19, 19, 101, 102, 19, 19, 19, 19, 19, 19, 19, 19, +19, 19, 19, 19, 19, 19, 19, 19, 19, 103, 103, 103, 103, 103, 103, 103, +103, 103, 104, 104, 104, 104, 104, 104, 104, 103, 103, 5, 5, 5, 5, 104, +104, 104, 104, 104, 104, 104, 104, 104, 104, 104, 104, 5, 5, 5, 5, 5, 5, +5, 5, 5, 5, 5, 5, 5, 5, 103, 103, 103, 103, 103, 5, 5, 5, 5, 5, 5, 5, +104, 5, 104, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 105, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 29, 30, 29, 30, 104, 5, 29, 30, 0, 0, 106, 50, 50, 50, 4, 107, 0, +0, 0, 0, 5, 5, 108, 24, 109, 109, 109, 0, 110, 0, 111, 111, 112, 16, 16, +16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 0, 16, 16, +16, 16, 16, 16, 16, 16, 16, 113, 114, 114, 114, 115, 18, 18, 18, 18, 18, +18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 116, 18, 18, 18, 18, 18, +18, 18, 18, 18, 117, 118, 118, 119, 120, 121, 122, 122, 122, 123, 124, +125, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, +30, 29, 30, 29, 30, 29, 30, 126, 127, 128, 129, 130, 131, 4, 29, 30, 132, +29, 30, 19, 64, 64, 64, 133, 133, 133, 133, 133, 133, 133, 133, 133, 133, +133, 133, 133, 133, 133, 133, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, +16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, +16, 16, 16, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, +18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 134, +134, 134, 134, 134, 134, 134, 134, 134, 134, 134, 134, 134, 134, 134, +134, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, +30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 4, +24, 24, 24, 24, 24, 5, 5, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, +29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, +29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, +29, 30, 29, 30, 29, 30, 135, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, +30, 29, 30, 136, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, +29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, +29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, +29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, +29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, +29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 0, 137, 137, 137, 137, 137, 137, +137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, +137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, +137, 137, 137, 137, 0, 0, 104, 4, 4, 4, 4, 4, 5, 19, 138, 138, 138, 138, +138, 138, 138, 138, 138, 138, 138, 138, 138, 138, 138, 138, 138, 138, +138, 138, 138, 138, 138, 138, 138, 138, 138, 138, 138, 138, 138, 138, +138, 138, 138, 138, 138, 138, 139, 19, 4, 4, 0, 0, 4, 4, 4, 0, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 4, 24, 4, 24, 24, 4, 24, 24, 4, 24, 0, 0, 0, +0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 0, 0, 55, 55, +55, 55, 4, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 20, 20, 20, 20, 20, 20, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 4, +20, 4, 4, 4, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 104, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 6, 7, 8, 9, 10, 11, +12, 13, 14, 15, 4, 4, 4, 4, 55, 55, 24, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 4, 55, 24, 24, 24, 24, 24, 24, 24, 20, 4, 24, 24, 24, 24, 24, 24, +104, 104, 24, 24, 4, 24, 24, 24, 24, 55, 55, 6, 7, 8, 9, 10, 11, 12, 13, +14, 15, 55, 55, 55, 4, 4, 55, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +0, 20, 55, 24, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +55, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 7, 8, 9, 10, 11, 12, 13, +14, 15, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 24, +24, 24, 24, 24, 24, 24, 24, 24, 104, 104, 4, 4, 4, 4, 104, 0, 0, 24, 4, +4, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 24, 24, 24, 24, 104, 24, 24, 24, 24, 24, 24, 24, 24, +24, 104, 24, 24, 24, 104, 24, 24, 24, 24, 24, 0, 0, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 24, 24, 24, 0, 0, +4, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 0, 0, 0, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 5, 55, 55, 55, 55, 55, 55, 55, 20, 20, 0, 0, 0, 0, 0, 24, +24, 24, 24, 24, 24, 24, 24, 24, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 104, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 20, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 17, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +24, 17, 24, 55, 17, 17, 17, 24, 24, 24, 24, 24, 24, 24, 24, 17, 17, 17, +17, 24, 17, 17, 55, 24, 24, 24, 24, 24, 24, 24, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 24, 24, 4, 4, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 4, 104, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 24, 17, 17, +0, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 55, 55, 0, 0, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +0, 55, 55, 55, 55, 55, 55, 55, 0, 55, 0, 0, 0, 55, 55, 55, 55, 0, 0, 24, +55, 17, 17, 17, 24, 24, 24, 24, 0, 0, 17, 17, 0, 0, 17, 17, 24, 55, 0, 0, +0, 0, 0, 0, 0, 0, 17, 0, 0, 0, 0, 55, 55, 0, 55, 55, 55, 24, 24, 0, 0, 6, +7, 8, 9, 10, 11, 12, 13, 14, 15, 55, 55, 4, 4, 26, 26, 26, 26, 26, 26, 4, +4, 55, 4, 24, 0, 0, 24, 24, 17, 0, 55, 55, 55, 55, 55, 55, 0, 0, 0, 0, +55, 55, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 0, 55, 55, 55, 55, 55, 55, 55, 0, 55, 55, 0, +55, 55, 0, 55, 55, 0, 0, 24, 0, 17, 17, 17, 24, 24, 0, 0, 0, 0, 24, 24, +0, 0, 24, 24, 24, 0, 0, 0, 24, 0, 0, 0, 0, 0, 0, 0, 55, 55, 55, 55, 0, +55, 0, 0, 0, 0, 0, 0, 0, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 24, 24, 55, +55, 55, 24, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24, 24, 17, 0, 55, 55, 55, +55, 55, 55, 55, 55, 55, 0, 55, 55, 55, 0, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 55, 55, 55, +55, 55, 55, 55, 0, 55, 55, 0, 55, 55, 55, 55, 55, 0, 0, 24, 55, 17, 17, +17, 24, 24, 24, 24, 24, 0, 24, 24, 17, 0, 17, 17, 24, 0, 0, 55, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 55, 24, 24, 0, 0, 6, 7, 8, 9, 10, +11, 12, 13, 14, 15, 4, 4, 0, 0, 0, 0, 0, 0, 0, 55, 24, 24, 24, 24, 24, +24, 0, 24, 17, 17, 0, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 55, 55, 0, 0, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 0, 55, 55, 55, 55, 55, 55, 55, 0, 55, 55, 0, 55, 55, 55, +55, 55, 0, 0, 24, 55, 17, 24, 17, 24, 24, 24, 24, 0, 0, 17, 17, 0, 0, 17, +17, 24, 0, 0, 0, 0, 0, 0, 0, 24, 24, 17, 0, 0, 0, 0, 55, 55, 0, 55, 55, +55, 24, 24, 0, 0, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 4, 55, 26, 26, 26, +26, 26, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24, 55, 0, 55, 55, 55, 55, 55, +55, 0, 0, 0, 55, 55, 55, 0, 55, 55, 55, 55, 0, 0, 0, 55, 55, 0, 55, 0, +55, 55, 0, 0, 0, 55, 55, 0, 0, 0, 55, 55, 55, 0, 0, 0, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 0, 0, 17, 17, 24, 17, 17, 0, 0, 0, +17, 17, 17, 0, 17, 17, 17, 24, 0, 0, 55, 0, 0, 0, 0, 0, 0, 17, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 26, +26, 26, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 24, 17, 17, 17, 24, 55, +55, 55, 55, 55, 55, 55, 55, 0, 55, 55, 55, 0, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 24, 55, +24, 24, 24, 17, 17, 17, 17, 0, 24, 24, 24, 0, 24, 24, 24, 24, 0, 0, 0, 0, +0, 0, 0, 24, 24, 0, 55, 55, 55, 0, 55, 55, 0, 0, 55, 55, 24, 24, 0, 0, 6, +7, 8, 9, 10, 11, 12, 13, 14, 15, 0, 0, 0, 0, 0, 0, 0, 4, 26, 26, 26, 26, +26, 26, 26, 4, 55, 24, 17, 17, 4, 55, 55, 55, 55, 55, 55, 55, 55, 0, 55, +55, 55, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 0, 55, 55, 55, 55, 55, 0, 0, 24, 55, 17, 24, 17, 17, 17, 17, 17, 0, +24, 17, 17, 0, 17, 17, 24, 24, 0, 0, 0, 0, 0, 0, 0, 17, 17, 0, 0, 0, 0, +0, 55, 55, 55, 0, 55, 55, 24, 24, 0, 0, 6, 7, 8, 9, 10, 11, 12, 13, 14, +15, 0, 55, 55, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24, 24, 17, 17, +55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 55, 55, 55, 0, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +24, 24, 55, 17, 17, 17, 24, 24, 24, 24, 0, 17, 17, 17, 0, 17, 17, 17, 24, +55, 4, 0, 0, 0, 0, 55, 55, 55, 17, 26, 26, 26, 26, 26, 26, 26, 55, 55, +55, 24, 24, 0, 0, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 26, 26, 26, 26, 26, +26, 26, 26, 26, 4, 55, 55, 55, 55, 55, 55, 0, 24, 17, 17, 0, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 0, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 55, 0, 0, +55, 55, 55, 55, 55, 55, 55, 0, 0, 0, 24, 0, 0, 0, 0, 17, 17, 17, 24, 24, +24, 0, 24, 0, 17, 17, 17, 17, 17, 17, 17, 17, 0, 0, 0, 0, 0, 0, 6, 7, 8, +9, 10, 11, 12, 13, 14, 15, 0, 0, 17, 17, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 24, 55, 140, 24, 24, +24, 24, 24, 24, 24, 0, 0, 0, 0, 4, 55, 55, 55, 55, 55, 55, 104, 24, 24, +24, 24, 24, 24, 24, 24, 4, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 4, 4, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 55, 0, 55, 0, 55, 55, 55, 55, 55, +0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 0, 55, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 24, 55, 140, 24, 24, 24, 24, 24, 24, 24, 24, 24, 55, 0, 0, 55, 55, +55, 55, 55, 0, 104, 0, 24, 24, 24, 24, 24, 24, 24, 0, 6, 7, 8, 9, 10, 11, +12, 13, 14, 15, 0, 0, 55, 55, 55, 55, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 24, 24, 4, 4, +4, 4, 4, 4, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 26, 26, 26, 26, 26, 26, +26, 26, 26, 26, 4, 24, 4, 24, 4, 24, 4, 4, 4, 4, 17, 17, 55, 55, 55, 55, +55, 55, 55, 55, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 0, 0, 0, 0, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 17, 24, 24, 24, 24, 24, 4, 24, 24, 55, 55, 55, 55, 55, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 0, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 0, 4, 4, 4, 4, 4, 4, 4, +4, 24, 4, 4, 4, 4, 4, 4, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 17, 17, 24, +24, 24, 24, 17, 24, 24, 24, 24, 24, 24, 17, 24, 24, 17, 17, 24, 24, 55, +6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 4, 4, 4, 4, 4, 4, 55, 55, 55, 55, 55, +55, 17, 17, 24, 24, 55, 55, 55, 55, 24, 24, 24, 55, 17, 17, 17, 55, 55, +17, 17, 17, 17, 17, 17, 17, 55, 55, 55, 24, 24, 24, 24, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 24, 17, 17, 24, 24, 17, 17, 17, 17, +17, 17, 24, 55, 17, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17, 17, 17, 24, +4, 4, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, +141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, +141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 0, 141, 0, 0, 0, +0, 0, 141, 0, 0, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, +142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, +142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, +142, 142, 142, 142, 4, 103, 142, 142, 142, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 55, 55, 55, +55, 0, 0, 55, 55, 55, 55, 55, 55, 55, 0, 55, 0, 55, 55, 55, 55, 0, 0, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 0, 55, 55, 55, 55, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 0, 55, 55, 55, 55, 0, 0, 55, 55, 55, 55, 55, +55, 55, 0, 55, 0, 55, 55, 55, 55, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 55, 55, 55, 55, 0, 0, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 24, 24, 24, 4, 4, +4, 4, 4, 4, 4, 4, 4, 143, 144, 145, 146, 147, 148, 149, 150, 151, 26, 26, +26, 26, 26, 26, 26, 26, 26, 26, 26, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, +0, 0, 0, 0, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, +164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, +178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, +192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, +206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, +220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, +234, 235, 236, 237, 0, 0, 238, 239, 240, 241, 242, 243, 0, 0, 4, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +4, 4, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +1, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 4, 4, 0, 0, 0, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 4, 4, 4, +244, 244, 244, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 0, 0, 0, 0, 0, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 24, +24, 24, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 24, 24, 17, 4, 4, 0, 0, 0, 0, +0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 24, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 55, 55, 55, 0, 24, 24, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 24, 24, 17, 24, 24, 24, 24, 24, 24, 24, 17, 17, 17, +17, 17, 17, 17, 17, 24, 17, 17, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 4, 4, 4, 104, 4, 4, 4, 4, 55, 24, 0, 0, 6, 7, 8, 9, 10, 11, 12, 13, +14, 15, 0, 0, 0, 0, 0, 0, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 0, 0, +0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 24, 24, 24, 20, 24, 6, 7, 8, +9, 10, 11, 12, 13, 14, 15, 0, 0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 104, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 0, 0, 0, 0, 0, 55, 55, 55, +55, 55, 245, 245, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 24, 55, 0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 0, 24, 24, 24, 17, 17, 17, 17, 24, 24, +17, 17, 17, 0, 0, 0, 0, 17, 17, 24, 17, 17, 17, 17, 17, 17, 24, 24, 24, +0, 0, 0, 0, 4, 0, 0, 0, 4, 4, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 55, 55, 55, 55, 55, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 0, 0, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 0, 0, 0, 0, 6, 7, 8, 9, 10, 11, 12, +13, 14, 15, 143, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +24, 24, 17, 17, 24, 0, 0, 4, 4, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 17, 24, 17, 24, 24, 24, 24, 24, 24, 24, 0, +24, 17, 24, 17, 17, 24, 24, 24, 24, 24, 24, 24, 24, 17, 17, 17, 17, 17, +17, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 0, 0, 24, 6, 7, 8, 9, 10, 11, +12, 13, 14, 15, 0, 0, 0, 0, 0, 0, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0, +0, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 104, 4, 4, 4, 4, 4, 4, 0, 0, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 5, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 0, 0, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +24, 24, 24, 24, 17, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 24, 17, +24, 24, 24, 24, 24, 17, 24, 17, 17, 17, 17, 17, 24, 17, 17, 55, 55, 55, +55, 55, 55, 55, 55, 0, 4, 4, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 24, 24, 24, 24, 24, 24, 24, 24, +24, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 24, 24, 17, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 17, 24, 24, 24, 24, 17, 17, 24, 24, 17, 24, +24, 24, 55, 55, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 24, 17, 24, 24, 17, 17, 17, 24, 17, 24, 24, 24, 17, 17, 0, 0, +0, 0, 0, 0, 0, 0, 4, 4, 4, 4, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 17, 17, 17, 17, 17, 17, 17, 17, 24, 24, 24, +24, 24, 24, 24, 24, 17, 17, 24, 24, 0, 0, 0, 4, 4, 4, 4, 4, 6, 7, 8, 9, +10, 11, 12, 13, 14, 15, 0, 0, 0, 55, 55, 55, 6, 7, 8, 9, 10, 11, 12, 13, +14, 15, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 104, 104, 104, +104, 104, 104, 4, 4, 246, 247, 248, 249, 250, 251, 252, 253, 254, 29, 30, +0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, +255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, +255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, +255, 255, 255, 255, 0, 0, 255, 255, 255, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, +0, 0, 0, 0, 0, 24, 24, 24, 4, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 17, 24, 24, 24, 24, 24, 24, 24, 55, 55, 55, 55, 24, 55, 55, 55, +55, 55, 55, 24, 55, 55, 17, 24, 24, 55, 0, 0, 0, 0, 0, 19, 19, 19, 19, +19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, +19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, +19, 19, 19, 19, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, +103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, +103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, +103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, +103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 19, 19, 19, 19, 19, 19, +19, 19, 19, 19, 19, 19, 19, 103, 256, 19, 19, 19, 257, 19, 19, 19, 19, +19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 258, 19, 19, 19, 19, 19, +19, 19, 19, 19, 19, 19, 19, 103, 103, 103, 103, 103, 103, 103, 103, 103, +103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, +103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 29, 30, 29, 30, 29, 30, 29, 30, 29, +30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, +30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, +30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, +30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, +30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, +30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, +30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, +30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 259, 260, +261, 262, 263, 264, 19, 19, 265, 19, 29, 30, 29, 30, 29, 30, 29, 30, 29, +30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, +30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, +30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, +30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, +30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 266, 266, +266, 266, 266, 266, 266, 266, 267, 267, 267, 267, 267, 267, 267, 267, +266, 266, 266, 266, 266, 266, 0, 0, 267, 267, 267, 267, 267, 267, 0, 0, +266, 266, 266, 266, 266, 266, 266, 266, 267, 267, 267, 267, 267, 267, +267, 267, 266, 266, 266, 266, 266, 266, 266, 266, 267, 267, 267, 267, +267, 267, 267, 267, 266, 266, 266, 266, 266, 266, 0, 0, 267, 267, 267, +267, 267, 267, 0, 0, 268, 266, 269, 266, 270, 266, 271, 266, 0, 267, 0, +267, 0, 267, 0, 267, 266, 266, 266, 266, 266, 266, 266, 266, 267, 267, +267, 267, 267, 267, 267, 267, 272, 272, 273, 273, 273, 273, 274, 274, +275, 275, 276, 276, 277, 277, 0, 0, 278, 279, 280, 281, 282, 283, 284, +285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, +299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, +313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 266, +266, 326, 327, 328, 0, 329, 330, 267, 267, 331, 331, 332, 5, 333, 5, 5, +5, 334, 335, 336, 0, 337, 338, 339, 339, 339, 339, 340, 5, 5, 5, 266, +266, 341, 342, 0, 0, 343, 344, 267, 267, 345, 345, 0, 5, 5, 5, 266, 266, +346, 347, 348, 128, 349, 350, 267, 267, 351, 351, 132, 5, 5, 5, 0, 0, +352, 353, 354, 0, 355, 356, 357, 357, 358, 358, 359, 5, 5, 0, 1, 1, 1, 1, +1, 1, 1, 1, 1, 1, 1, 20, 360, 360, 20, 20, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 4, 4, 5, 2, 2, 20, 20, 20, 20, 20, 1, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 17, 17, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 17, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 1, 20, +20, 20, 20, 20, 0, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 361, 103, 0, +0, 362, 363, 364, 365, 366, 367, 4, 4, 4, 4, 4, 103, 361, 25, 21, 22, +362, 363, 364, 365, 366, 367, 4, 4, 4, 4, 4, 0, 103, 103, 103, 103, 103, +103, 103, 103, 103, 103, 103, 103, 103, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 5, 5, 5, 5, 24, 5, 5, 5, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +4, 4, 122, 4, 4, 4, 4, 122, 4, 4, 19, 122, 122, 122, 19, 19, 122, 122, +122, 19, 4, 122, 4, 4, 368, 122, 122, 122, 122, 122, 4, 4, 4, 4, 4, 4, +122, 4, 369, 4, 122, 4, 370, 371, 122, 122, 368, 19, 122, 122, 372, 122, +19, 55, 55, 55, 55, 19, 4, 4, 19, 19, 122, 122, 4, 4, 4, 4, 4, 122, 19, +19, 19, 19, 4, 4, 4, 4, 373, 4, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, +26, 26, 26, 26, 26, 26, 374, 374, 374, 374, 374, 374, 374, 374, 374, 374, +374, 374, 374, 374, 374, 374, 375, 375, 375, 375, 375, 375, 375, 375, +375, 375, 375, 375, 375, 375, 375, 375, 244, 244, 244, 29, 30, 244, 244, +244, 244, 26, 4, 4, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 25, 21, 22, 362, 363, 364, 365, 366, 367, +26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 25, 21, 22, 362, 363, 364, +365, 366, 367, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 25, 21, 22, +362, 363, 364, 365, 366, 367, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 376, 376, 376, 376, 376, 376, 376, 376, 376, 376, 376, 376, 376, +376, 376, 376, 376, 376, 376, 376, 376, 376, 376, 376, 376, 376, 377, +377, 377, 377, 377, 377, 377, 377, 377, 377, 377, 377, 377, 377, 377, +377, 377, 377, 377, 377, 377, 377, 377, 377, 377, 377, 361, 26, 26, 26, +26, 26, 26, 26, 26, 26, 26, 25, 21, 22, 362, 363, 364, 365, 366, 367, 26, +361, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 25, +21, 22, 362, 363, 364, 365, 366, 367, 26, 25, 21, 22, 362, 363, 364, 365, +366, 367, 26, 25, 21, 22, 362, 363, 364, 365, 366, 367, 26, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 137, 137, 137, 137, 137, +137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, +137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, +137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, +137, 138, 138, 138, 138, 138, 138, 138, 138, 138, 138, 138, 138, 138, +138, 138, 138, 138, 138, 138, 138, 138, 138, 138, 138, 138, 138, 138, +138, 138, 138, 138, 138, 138, 138, 138, 138, 138, 138, 138, 138, 138, +138, 138, 138, 138, 138, 138, 138, 29, 30, 378, 379, 380, 381, 382, 29, +30, 29, 30, 29, 30, 383, 384, 385, 386, 19, 29, 30, 19, 29, 30, 19, 19, +19, 19, 19, 103, 103, 387, 387, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, +29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, +29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, +29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, +29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, +29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, +19, 4, 4, 4, 4, 4, 4, 29, 30, 29, 30, 24, 24, 24, 29, 30, 0, 0, 0, 0, 0, +4, 4, 4, 4, 26, 4, 4, 388, 388, 388, 388, 388, 388, 388, 388, 388, 388, +388, 388, 388, 388, 388, 388, 388, 388, 388, 388, 388, 388, 388, 388, +388, 388, 388, 388, 388, 388, 388, 388, 388, 388, 388, 388, 388, 388, 0, +388, 0, 0, 0, 0, 0, 388, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 0, 0, 0, 0, 0, 104, 4, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 0, +0, 0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 0, 55, 55, 55, 55, 55, 55, +55, 0, 55, 55, 55, 55, 55, 55, 55, 0, 55, 55, 55, 55, 55, 55, 55, 0, 55, +55, 55, 55, 55, 55, 55, 0, 55, 55, 55, 55, 55, 55, 55, 0, 55, 55, 55, 55, +55, 55, 55, 0, 55, 55, 55, 55, 55, 55, 55, 0, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 389, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 1, 4, 4, 4, 4, 104, 55, 244, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 244, 244, 244, +244, 244, 244, 244, 244, 244, 24, 24, 24, 24, 17, 17, 4, 104, 104, 104, +104, 104, 4, 4, 244, 244, 244, 104, 55, 4, 4, 4, 0, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 24, 24, 5, 5, 104, 104, 55, 4, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +17, 104, 104, 104, 55, 0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 0, 4, 4, 26, 26, 26, 26, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 26, 26, +26, 26, 26, 26, 26, 26, 26, 26, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 26, 26, 26, 26, 26, 26, +26, 26, 4, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, +26, 26, 26, 26, 26, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 55, 55, +55, 55, 55, 390, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 390, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 390, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 390, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 390, 55, 55, 390, 55, 55, 55, 390, +55, 390, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 390, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 390, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 390, 55, 55, 55, 55, 55, 55, 55, 390, 55, 390, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 390, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 390, 390, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +390, 55, 55, 55, 55, 55, 55, 55, 55, 390, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 390, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 390, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 390, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 390, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 390, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 390, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +390, 55, 390, 55, 390, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 390, +55, 390, 390, 390, 55, 55, 55, 55, 55, 55, 390, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 390, 390, 390, 390, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 390, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 390, 55, 55, 55, 55, 55, 55, 55, 390, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 390, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +390, 390, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 390, 390, 390, +55, 390, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 390, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 390, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 390, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 390, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 390, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 390, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 390, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 390, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 390, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 390, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 390, 55, 55, +55, 55, 390, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 390, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 390, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 390, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 390, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 390, 55, 55, 55, 55, 55, 390, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 390, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 390, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 104, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 0, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 104, 104, 104, +104, 104, 104, 4, 4, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 104, +4, 4, 4, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 55, 55, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, +30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, +30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 55, +24, 5, 5, 5, 4, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 4, 104, 29, 30, +29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, +29, 30, 29, 30, 29, 30, 29, 30, 103, 103, 24, 24, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 244, 244, 244, 244, 244, 244, +244, 244, 244, 244, 24, 24, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 5, +5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 104, +104, 104, 104, 104, 104, 104, 104, 104, 5, 5, 29, 30, 29, 30, 29, 30, 29, +30, 29, 30, 29, 30, 29, 30, 19, 19, 29, 30, 29, 30, 29, 30, 29, 30, 29, +30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, +30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, +30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 103, +19, 19, 19, 19, 19, 19, 19, 19, 29, 30, 29, 30, 391, 29, 30, 29, 30, 29, +30, 29, 30, 29, 30, 104, 5, 5, 29, 30, 392, 19, 55, 29, 30, 29, 30, 393, +19, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, +30, 29, 30, 394, 395, 396, 397, 394, 19, 398, 399, 400, 401, 29, 30, 29, +30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 402, 403, 404, 29, +30, 29, 30, 405, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, +29, 30, 406, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +103, 103, 103, 103, 29, 30, 55, 103, 103, 19, 55, 55, 55, 55, 55, 55, 55, +24, 55, 55, 55, 24, 55, 55, 55, 55, 24, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 17, 17, 24, +24, 17, 4, 4, 4, 4, 24, 0, 0, 0, 26, 26, 26, 26, 26, 26, 4, 4, 4, 4, 0, +0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 17, 17, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 17, 17, 17, 17, 17, 17, 17, 17, 17, +17, 17, 17, 17, 17, 17, 17, 24, 24, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 6, 7, +8, 9, 10, 11, 12, 13, 14, 15, 0, 0, 0, 0, 0, 0, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 55, 55, 55, 55, 55, 55, +4, 4, 4, 55, 4, 55, 55, 24, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 24, 24, 24, 24, 24, 24, 24, 24, 4, 4, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 17, 17, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +0, 0, 0, 24, 24, 24, 17, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 24, +17, 17, 24, 24, 24, 24, 17, 17, 24, 24, 17, 17, 17, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 0, 104, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0, 0, 0, 0, +4, 4, 55, 55, 55, 55, 55, 24, 104, 55, 55, 55, 55, 55, 55, 55, 55, 55, 6, +7, 8, 9, 10, 11, 12, 13, 14, 15, 55, 55, 55, 55, 55, 0, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 24, 24, 24, 24, 24, 24, 17, 17, 24, 24, 17, 17, 24, 24, 0, 0, 0, 0, +0, 0, 0, 0, 0, 55, 55, 55, 24, 55, 55, 55, 55, 55, 55, 55, 55, 24, 17, 0, +0, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0, 0, 4, 4, 4, 4, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 104, 55, 55, 55, 55, 55, +55, 4, 4, 4, 55, 17, 24, 17, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 24, 55, 24, 24, 24, 55, 55, 24, 24, 55, 55, 55, 55, 55, 24, +24, 55, 24, 55, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 55, 55, 104, 4, 4, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 17, 24, 24, 17, 17, 4, 4, 55, 104, 104, 17, 24, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 55, 55, 55, 55, 55, 55, 0, 0, 55, 55, 55, 55, 55, 55, 0, 0, 55, +55, 55, 55, 55, 55, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, +55, 0, 55, 55, 55, 55, 55, 55, 55, 0, 19, 19, 19, 19, 19, 19, 19, 19, 19, +19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, +19, 19, 19, 19, 19, 19, 19, 19, 407, 19, 19, 19, 19, 19, 19, 19, 5, 103, +103, 103, 103, 19, 19, 19, 19, 19, 19, 19, 19, 19, 103, 5, 5, 0, 0, 0, 0, +408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, +422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, +436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, +450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, +464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, +478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 17, 17, 24, 17, 17, 24, 17, +17, 4, 17, 24, 0, 0, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0, 0, 0, 0, 0, +0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 0, 0, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 390, 55, 55, 55, 55, 55, 55, 55, 390, 55, 55, 55, 55, 390, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 390, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 390, 55, +390, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 390, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 488, 489, 490, 491, 492, 493, 494, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 495, 496, 497, 498, 499, 0, 0, 0, 0, 0, 55, 24, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 4, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 0, 55, 55, 55, 55, 55, 0, 55, 0, 55, 55, 0, 55, 55, 0, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 5, 5, 5, 5, +5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 500, +500, 500, 500, 500, 500, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 4, 4, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 4, 4, 4, 4, 4, 4, 4, 4, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 500, 500, +4, 4, 4, 4, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 4, 4, 4, 5, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 4, 4, 4, 17, 17, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 17, 17, 17, +4, 4, 5, 0, 4, 5, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, +4, 4, 4, 4, 0, 0, 0, 0, 500, 55, 500, 55, 500, 0, 500, 55, 500, 55, 500, +55, 500, 55, 500, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 0, 0, 20, 0, 4, 4, 4, 4, 4, 4, 5, 4, 4, 4, 4, 4, 4, 5, 4, +6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 5, 4, 4, 4, 4, 4, 4, 16, 16, 16, 16, +16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, +16, 16, 16, 16, 4, 4, 4, 5, 17, 5, 18, 18, 18, 18, 18, 18, 18, 18, 18, +18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 17, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 104, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 501, 501, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 0, 0, 0, 55, 55, 55, 55, 55, 55, 0, 0, 55, 55, +55, 55, 55, 55, 0, 0, 55, 55, 55, 55, 55, 55, 0, 0, 55, 55, 55, 0, 0, 0, +4, 4, 4, 5, 4, 4, 4, 0, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 20, 20, 20, 4, 4, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 55, 55, 0, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 0, 0, 0, 4, 4, +4, 0, 0, 0, 0, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, +26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, +26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 0, 0, 0, 4, 4, 4, 4, +4, 4, 4, 4, 4, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, +244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, +244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, +244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 26, +26, 26, 26, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 26, 26, 4, +4, 4, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 4, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 24, 0, 0, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24, 26, 26, +26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, +26, 26, 26, 26, 26, 26, 26, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 26, 26, 26, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 244, 55, 55, 55, 55, 55, 55, 55, 55, 244, 0, 0, 0, 0, 0, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 24, +24, 24, 24, 24, 0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 0, 4, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 4, 244, 244, 244, +244, 244, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 502, 502, +502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, +502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, +502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 503, 503, 503, 503, +503, 503, 503, 503, 503, 503, 503, 503, 503, 503, 503, 503, 503, 503, +503, 503, 503, 503, 503, 503, 503, 503, 503, 503, 503, 503, 503, 503, +503, 503, 503, 503, 503, 503, 503, 503, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 6, +7, 8, 9, 10, 11, 12, 13, 14, 15, 0, 0, 0, 0, 0, 0, 502, 502, 502, 502, +502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, +502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, +502, 502, 502, 502, 0, 0, 0, 0, 503, 503, 503, 503, 503, 503, 503, 503, +503, 503, 503, 503, 503, 503, 503, 503, 503, 503, 503, 503, 503, 503, +503, 503, 503, 503, 503, 503, 503, 503, 503, 503, 503, 503, 503, 503, 0, +0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 0, 0, 0, 0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +4, 504, 504, 504, 504, 504, 504, 504, 504, 504, 504, 504, 0, 504, 504, +504, 504, 504, 504, 504, 504, 504, 504, 504, 504, 504, 504, 504, 0, 504, +504, 504, 504, 504, 504, 504, 0, 504, 504, 0, 505, 505, 505, 505, 505, +505, 505, 505, 505, 505, 505, 0, 505, 505, 505, 505, 505, 505, 505, 505, +505, 505, 505, 505, 505, 505, 505, 0, 505, 505, 505, 505, 505, 505, 505, +0, 505, 505, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 0, 0, 0, 0, 0, +0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, +55, 55, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 103, 104, 104, 103, 103, 103, 0, 103, 103, 103, 103, 103, 103, 103, +103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, +103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, +103, 103, 103, 103, 103, 103, 103, 0, 103, 103, 103, 103, 103, 103, 103, +103, 103, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +55, 55, 55, 55, 55, 55, 0, 0, 55, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, +55, 55, 0, 0, 0, 55, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 4, 26, 26, 26, 26, 26, +26, 26, 26, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 4, 4, 26, 26, 26, 26, 26, 26, 26, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 0, 0, 0, 0, 0, 0, 26, +26, 26, 26, 26, 26, 26, 26, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 0, 55, 55, 0, 0, 0, 0, 0, 26, 26, 26, 26, +26, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 26, 26, 26, 26, 26, 26, 0, 0, 0, 4, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 0, 0, 0, 0, 0, 4, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 0, 0, 26, 26, 55, 55, 26, +26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 0, 0, 26, 26, +26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, +26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, +26, 26, 26, 26, 26, 26, 26, 26, 55, 24, 24, 24, 0, 24, 24, 0, 0, 0, 0, 0, +24, 24, 24, 24, 55, 55, 55, 55, 0, 55, 55, 55, 0, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 0, 0, 24, 24, 24, 0, 0, 0, 0, 24, 25, 21, 22, 362, +26, 26, 26, 26, 26, 0, 0, 0, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, +0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 26, 26, 4, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 26, 26, 26, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 4, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 24, 24, 0, 0, 0, 0, 26, 26, 26, 26, 26, 4, 4, 4, 4, 4, 4, 4, 0, +0, 0, 0, 0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, +26, 26, 26, 26, 26, 26, 26, 26, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 0, 0, 0, 26, 26, 26, 26, 26, +26, 26, 26, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 0, 0, 0, 0, 0, 0, 0, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 26, 26, 26, 26, 26, 26, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, +110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, +110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, +110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 117, 117, 117, 117, 117, 117, 117, 117, 117, 117, +117, 117, 117, 117, 117, 117, 117, 117, 117, 117, 117, 117, 117, 117, +117, 117, 117, 117, 117, 117, 117, 117, 117, 117, 117, 117, 117, 117, +117, 117, 117, 117, 117, 117, 117, 117, 117, 117, 117, 117, 117, 0, 0, 0, +0, 0, 0, 0, 26, 26, 26, 26, 26, 26, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 24, 24, 24, 24, 0, 0, 0, 0, 0, 0, 0, +0, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0, 0, 0, 0, 0, 0, 6, 7, 8, 9, 10, +11, 12, 13, 14, 15, 55, 55, 55, 55, 104, 55, 16, 16, 16, 16, 16, 16, 16, +16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 0, 0, 0, 24, +24, 24, 24, 24, 4, 104, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, +18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 25, 21, 22, 362, 363, 364, +365, 366, 367, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, +26, 26, 26, 26, 26, 26, 26, 26, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 24, 24, 4, +0, 0, 55, 55, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 55, 55, +104, 55, 55, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 24, 24, 24, 24, 24, 24, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 55, 0, 0, 0, 0, 0, 0, +0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 26, 26, +26, 26, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 24, 24, 24, 24, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 26, 26, 26, 26, 26, 26, 26, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 0, 0, +0, 0, 0, 0, 0, 17, 24, 17, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 25, 21, 22, 362, 363, 364, +365, 366, 367, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 6, 7, 8, 9, +10, 11, 12, 13, 14, 15, 24, 55, 55, 24, 24, 55, 0, 0, 0, 0, 0, 0, 0, 0, +0, 24, 24, 24, 17, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 17, 17, 17, 24, +24, 24, 24, 17, 17, 24, 24, 4, 4, 20, 4, 4, 4, 4, 24, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 20, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 0, 0, 0, 0, 0, 6, +7, 8, 9, 10, 11, 12, 13, 14, 15, 0, 0, 0, 0, 0, 0, 24, 24, 24, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 24, 24, +24, 24, 24, 17, 24, 24, 24, 24, 24, 24, 24, 24, 0, 6, 7, 8, 9, 10, 11, +12, 13, 14, 15, 4, 4, 4, 4, 55, 17, 17, 55, 0, 0, 0, 0, 0, 0, 0, 0, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 24, 4, 4, +55, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24, 24, 17, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 17, 17, 17, 24, 24, 24, 24, 24, 24, 24, 24, 24, 17, +17, 55, 55, 55, 55, 4, 4, 4, 4, 24, 24, 24, 24, 4, 17, 24, 6, 7, 8, 9, +10, 11, 12, 13, 14, 15, 55, 4, 55, 4, 4, 4, 0, 26, 26, 26, 26, 26, 26, +26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 17, 17, 17, 24, 24, 24, +17, 17, 24, 17, 24, 24, 4, 4, 4, 4, 4, 4, 24, 55, 55, 24, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 0, 55, 0, 55, 55, +55, 55, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 4, 0, 0, 0, 0, 0, 0, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 24, 17, 17, 17, 24, 24, 24, 24, 24, 24, +24, 24, 0, 0, 0, 0, 0, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0, 0, 0, 0, 0, +0, 24, 24, 17, 17, 0, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 55, 55, 0, 0, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 0, 55, 55, 55, 55, 55, 55, 55, 0, 55, 55, 0, 55, 55, 55, +55, 55, 0, 24, 24, 55, 17, 17, 24, 17, 17, 17, 17, 0, 0, 17, 17, 0, 0, +17, 17, 17, 0, 0, 55, 0, 0, 0, 0, 0, 0, 17, 0, 0, 0, 0, 0, 55, 55, 55, +55, 55, 17, 17, 0, 0, 24, 24, 24, 24, 24, 24, 24, 0, 0, 0, 24, 24, 24, +24, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 0, 55, 0, 0, 55, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 55, 17, 17, 17, 24, 24, 24, 24, +24, 24, 0, 17, 0, 0, 17, 0, 17, 17, 17, 17, 0, 17, 17, 24, 17, 24, 55, +24, 55, 4, 4, 0, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 24, 24, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 17, 17, +17, 24, 24, 24, 24, 24, 24, 24, 24, 17, 17, 24, 24, 24, 17, 24, 55, 55, +55, 55, 4, 4, 4, 4, 4, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 4, 4, 0, 4, +24, 55, 55, 55, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 17, 17, 17, 24, 24, 24, 24, 24, 24, 17, 24, 17, 17, 17, 17, 24, +24, 17, 24, 24, 55, 55, 4, 55, 0, 0, 0, 0, 0, 0, 0, 0, 6, 7, 8, 9, 10, +11, 12, 13, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 17, 17, 17, 24, 24, 24, 24, 0, 0, 17, 17, +17, 17, 24, 24, 17, 24, 24, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 55, 55, 55, 55, 24, 24, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 17, 17, 17, 24, 24, +24, 24, 24, 24, 24, 24, 17, 17, 24, 17, 24, 24, 4, 4, 4, 55, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0, 0, 0, 0, 0, +0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 24, 17, 24, 17, +17, 24, 24, 24, 24, 24, 24, 17, 24, 55, 4, 0, 0, 0, 0, 0, 0, 6, 7, 8, 9, +10, 11, 12, 13, 14, 15, 0, 0, 0, 0, 0, 0, 6, 7, 8, 9, 10, 11, 12, 13, 14, +15, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 0, 0, 24, 17, 24, 17, 17, 24, 24, 24, 24, 17, 24, 24, 24, +24, 24, 0, 0, 0, 0, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 26, 26, 4, 4, 4, +4, 55, 55, 55, 55, 55, 55, 55, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 17, 17, 17, 24, 24, 24, 24, 24, 24, 24, 24, 24, 17, 24, +24, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, +16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, +18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, +18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 6, 7, 8, 9, 10, +11, 12, 13, 14, 15, 26, 26, 26, 26, 26, 26, 26, 26, 26, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 55, 0, 0, 55, 55, +55, 55, 55, 55, 55, 55, 0, 55, 55, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 17, 17, 17, +17, 17, 17, 0, 17, 17, 0, 0, 24, 24, 17, 24, 55, 17, 55, 17, 24, 4, 4, 4, +0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 55, 55, 55, +55, 55, 55, 55, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 17, 17, 17, 24, 24, 24, 24, 0, 0, 24, 24, +17, 17, 17, 17, 24, 55, 4, 55, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 24, 24, 24, 24, 24, 24, 17, 55, 24, 24, 24, +24, 4, 4, 4, 4, 4, 4, 4, 4, 24, 0, 0, 0, 0, 0, 0, 0, 0, 55, 24, 24, 24, +24, 24, 24, 17, 17, 24, 24, 24, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 17, 24, 24, 4, 4, 4, +55, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 0, 0, +0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 24, 17, 24, 24, 24, 17, 24, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 7, 8, 9, 10, 11, 12, +13, 14, 15, 0, 0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +17, 24, 24, 24, 24, 24, 24, 24, 0, 24, 24, 24, 24, 24, 24, 17, 24, 55, 4, +4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 7, 8, 9, 10, 11, 12, 13, 14, +15, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, +26, 26, 0, 0, 0, 4, 4, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +0, 0, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 0, 17, 24, 24, 24, 24, 24, 24, 24, 17, 24, 24, 17, +24, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 0, 55, 55, 0, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 24, 24, 24, +24, 24, 24, 0, 0, 0, 24, 0, 24, 24, 0, 24, 24, 24, 24, 24, 24, 24, 55, +24, 0, 0, 0, 0, 0, 0, 0, 0, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0, 0, 0, +0, 0, 0, 55, 55, 55, 55, 55, 55, 0, 55, 55, 0, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 17, 17, 17, 17, 17, 0, 24, 24, 0, 17, 17, +24, 17, 24, 55, 0, 0, 0, 0, 0, 0, 0, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, +0, 0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 104, 55, 55, 0, 0, 0, 0, 6, 7, 8, 9, +10, 11, 12, 13, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 24, 24, 17, 17, 4, 4, 0, 0, 0, 0, 0, 0, 0, 24, 24, +55, 17, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 17, 17, 24, 24, +24, 24, 24, 0, 0, 0, 17, 17, 24, 17, 24, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 55, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 26, 26, +26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 390, 390, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 390, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +390, 55, 55, 55, 55, 390, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 390, 55, 390, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 390, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 244, 244, 244, +244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, +244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, +244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, +244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, +244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, +244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, +244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, +244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 0, 4, 4, 4, 4, 4, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 4, 4, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 24, 55, +55, 55, 55, 55, 55, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 17, 17, +17, 24, 24, 24, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 0, 0, 0, 0, +0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 6, 7, 8, 9, +10, 11, 12, 13, 14, 15, 0, 0, 0, 0, 4, 4, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 6, +7, 8, 9, 10, 11, 12, 13, 14, 15, 0, 0, 0, 0, 0, 0, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 0, 0, 24, 24, 24, 24, 24, 4, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 24, 24, +24, 24, 24, 24, 24, 4, 4, 4, 4, 4, 4, 4, 4, 4, 104, 104, 104, 104, 4, 4, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0, 26, +26, 26, 26, 26, 26, 26, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 0, 0, 0, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 104, 104, 104, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 104, 104, 4, 4, 4, 6, 7, 8, +9, 10, 11, 12, 13, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, +16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, +16, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, +18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 26, 26, 26, +26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, +26, 26, 4, 4, 4, 4, 0, 0, 0, 0, 0, 506, 506, 506, 506, 506, 506, 506, +506, 506, 506, 506, 506, 506, 506, 506, 506, 506, 506, 506, 506, 506, +506, 506, 506, 506, 0, 0, 507, 507, 507, 507, 507, 507, 507, 507, 507, +507, 507, 507, 507, 507, 507, 507, 507, 507, 507, 507, 507, 507, 507, +507, 507, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 0, 0, 0, 0, 24, 55, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, +17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, +17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, +17, 17, 17, 17, 17, 17, 17, 17, 0, 0, 0, 0, 0, 0, 0, 24, 24, 24, 24, 104, +104, 104, 104, 104, 104, 104, 104, 104, 104, 104, 104, 104, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 104, 104, 4, 104, 24, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 17, 17, 104, 104, 244, 244, 244, 0, 0, 0, 0, 0, 0, 0, +0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 104, +104, 104, 104, 0, 104, 104, 104, 104, 104, 104, 104, 0, 104, 104, 0, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 55, 55, 0, 0, +55, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 55, 55, 55, 0, 0, 0, 0, +0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, +0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, +0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 0, 0, 0, 0, 0, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 0, 0, 4, 24, 24, 4, 20, 20, 20, 20, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 4, 4, 4, +0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +0, 0, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 17, 17, 24, 24, 24, 4, 4, 4, +17, 17, 17, 17, 17, 17, 20, 20, 20, 20, 20, 20, 20, 20, 24, 24, 24, 24, +24, 24, 24, 24, 4, 4, 24, 24, 24, 24, 24, 24, 24, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 24, 24, +24, 24, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 24, 24, 24, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 26, 26, 26, 26, 26, 26, 26, +26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, +26, 26, 26, 26, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 26, 26, 26, 26, +26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, +26, 26, 0, 0, 0, 0, 0, 0, 0, 122, 122, 122, 122, 122, 122, 122, 122, 122, +122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, +122, 122, 122, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, +19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 122, 122, 122, 122, 122, +122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, +122, 122, 122, 122, 122, 122, 122, 19, 19, 19, 19, 19, 19, 19, 0, 19, 19, +19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 122, 122, +122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, +122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 19, 19, 19, 19, 19, 19, +19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, +19, 19, 122, 0, 122, 122, 0, 0, 122, 0, 0, 122, 122, 0, 0, 122, 122, 122, +122, 0, 122, 122, 122, 122, 122, 122, 122, 122, 19, 19, 19, 19, 0, 19, 0, +19, 19, 19, 19, 19, 19, 19, 0, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, +19, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, +122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 19, 19, 19, +19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, +19, 19, 19, 19, 19, 122, 122, 0, 122, 122, 122, 122, 0, 0, 122, 122, 122, +122, 122, 122, 122, 122, 0, 122, 122, 122, 122, 122, 122, 122, 0, 19, 19, +19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, +19, 19, 19, 19, 19, 19, 122, 122, 0, 122, 122, 122, 122, 0, 122, 122, +122, 122, 122, 0, 122, 0, 0, 0, 122, 122, 122, 122, 122, 122, 122, 0, 19, +19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, +19, 19, 19, 19, 19, 19, 19, 122, 122, 122, 122, 122, 122, 122, 122, 122, +122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, +122, 122, 122, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, +19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 122, 122, 122, 122, 122, +122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, +122, 122, 122, 122, 122, 122, 122, 19, 19, 19, 19, 19, 19, 19, 19, 19, +19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 122, +122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, +122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 19, 19, 19, 19, +19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, +19, 19, 19, 19, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, +122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, +122, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, +19, 19, 19, 19, 19, 19, 19, 19, 19, 122, 122, 122, 122, 122, 122, 122, +122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, +122, 122, 122, 122, 122, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, +19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 122, 122, 122, +122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, +122, 122, 122, 122, 122, 122, 122, 122, 122, 19, 19, 19, 19, 19, 19, 19, +19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, +19, 19, 19, 0, 0, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, +122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 4, +19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, +19, 19, 19, 19, 19, 19, 19, 4, 19, 19, 19, 19, 19, 19, 122, 122, 122, +122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, +122, 122, 122, 122, 122, 122, 122, 122, 4, 19, 19, 19, 19, 19, 19, 19, +19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, +4, 19, 19, 19, 19, 19, 19, 122, 122, 122, 122, 122, 122, 122, 122, 122, +122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, +122, 122, 4, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, +19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 4, 19, 19, 19, 19, 19, 19, 122, +122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, +122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 4, 19, 19, 19, 19, 19, +19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, +19, 19, 4, 19, 19, 19, 19, 19, 19, 122, 122, 122, 122, 122, 122, 122, +122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, +122, 122, 122, 122, 4, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, +19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 4, 19, 19, 19, 19, +19, 19, 122, 19, 0, 0, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 6, 7, 8, 9, +10, 11, 12, 13, 14, 15, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 6, 7, 8, 9, +10, 11, 12, 13, 14, 15, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 4, 4, 4, +4, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 4, 4, 4, 4, +4, 4, 4, 4, 24, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 24, 4, 4, 4, 4, +4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24, 24, 24, 24, 24, +0, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 55, 19, 19, 19, +19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 0, 0, +0, 0, 0, 0, 19, 19, 19, 19, 19, 19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 24, 24, 24, 24, 24, 24, 24, 0, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 0, 0, 24, 24, 24, 24, 24, 24, 24, 0, 24, 24, +0, 24, 24, 24, 24, 24, 0, 0, 0, 0, 0, 103, 103, 103, 103, 103, 103, 103, +103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, +103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, +103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, +103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 0, 24, 24, 24, 24, 24, 24, 24, 104, +104, 104, 104, 104, 104, 104, 0, 0, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, +0, 0, 0, 0, 55, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 24, 24, 24, 24, 6, 7, +8, 9, 10, 11, 12, 13, 14, 15, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 104, 24, 24, 24, 24, 6, 7, 8, 9, 10, +11, 12, 13, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 24, 24, 55, 6, 7, 8, 9, 10, 11, 12, +13, 14, 15, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 55, 55, 55, +24, 55, 55, 24, 55, 55, 55, 55, 55, 55, 55, 24, 24, 55, 55, 55, 55, 55, +24, 0, 0, 0, 0, 0, 0, 0, 0, 55, 104, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 0, 55, +55, 55, 55, 0, 55, 55, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 0, 0, 26, 26, 26, 26, 26, 26, 26, 26, 26, 24, 24, 24, 24, 24, 24, 24, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 508, 508, 508, 508, +508, 508, 508, 508, 508, 508, 508, 508, 508, 508, 508, 508, 508, 508, +508, 508, 508, 508, 508, 508, 508, 508, 508, 508, 508, 508, 508, 508, +508, 508, 509, 509, 509, 509, 509, 509, 509, 509, 509, 509, 509, 509, +509, 509, 509, 509, 509, 509, 509, 509, 509, 509, 509, 509, 509, 509, +509, 509, 509, 509, 509, 509, 509, 509, 24, 24, 24, 24, 24, 24, 24, 104, +0, 0, 0, 0, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0, 0, 0, 0, 4, 4, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, +26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, +26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, +26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, +26, 26, 26, 26, 4, 26, 26, 26, 4, 26, 26, 26, 26, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 26, 26, +26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, +26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, +26, 26, 26, 26, 26, 26, 4, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, +26, 26, 26, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, +55, 55, 55, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 55, 55, 0, 55, 0, +0, 55, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 55, 55, 55, 55, 0, +55, 0, 55, 0, 0, 0, 0, 0, 0, 55, 0, 0, 0, 0, 55, 0, 55, 0, 55, 0, 55, 55, +55, 0, 55, 55, 0, 55, 0, 0, 55, 0, 55, 0, 55, 0, 55, 0, 55, 0, 55, 55, 0, +55, 0, 0, 55, 55, 55, 55, 0, 55, 55, 55, 55, 55, 55, 55, 0, 55, 55, 55, +55, 0, 55, 55, 55, 55, 0, 55, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, +0, 0, 0, 0, 55, 55, 55, 0, 55, 55, 55, 55, 55, 0, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 361, 361, 25, 21, 22, 362, 363, 364, 365, 366, 367, 26, 26, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 510, 510, 510, 510, 510, 510, 510, 510, 510, +510, 510, 510, 510, 510, 510, 510, 510, 510, 510, 510, 510, 510, 510, +510, 510, 510, 4, 4, 4, 4, 4, 4, 510, 510, 510, 510, 510, 510, 510, 510, +510, 510, 510, 510, 510, 510, 510, 510, 510, 510, 510, 510, 510, 510, +510, 510, 510, 510, 4, 4, 4, 4, 4, 4, 510, 510, 510, 510, 510, 510, 510, +510, 510, 510, 510, 510, 510, 510, 510, 510, 510, 510, 510, 510, 510, +510, 510, 510, 510, 510, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 4, 4, +4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +0, 0, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 4, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, +0, 0, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 4, 0, 0, 0, 0, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, +4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 7, 8, 9, 10, 11, 12, 13, 14, +15, 4, 0, 0, 0, 0, 0, 55, 390, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 390, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 390, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 390, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 390, 55, 55, +55, 55, 55, 55, 55, 55, 390, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 390, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 390, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 390, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 390, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 390, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 390, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 390, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 0, 0, 0, 0, 0, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, +55, 55, 55, 0, 0, 0, 0, 0, 0, 0, 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 20, 20, 20, 20, 20, +20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, +20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, +20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, +20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, +20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, +20, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +0, +}; +/* Returns the numeric value as double for Unicode characters +* having this property, -1.0 otherwise. +*/ +double _PyUnicode_ToNumeric(Py_UCS4 ch) +{ +switch (ch) { +case 0x0F33: +return (double) -1.0/2.0; +case 0x0030: +case 0x0660: +case 0x06F0: +case 0x07C0: +case 0x0966: +case 0x09E6: +case 0x0A66: +case 0x0AE6: +case 0x0B66: +case 0x0BE6: +case 0x0C66: +case 0x0C78: +case 0x0CE6: +case 0x0D66: +case 0x0DE6: +case 0x0E50: +case 0x0ED0: +case 0x0F20: +case 0x1040: +case 0x1090: +case 0x17E0: +case 0x17F0: +case 0x1810: +case 0x1946: +case 0x19D0: +case 0x1A80: +case 0x1A90: +case 0x1B50: +case 0x1BB0: +case 0x1C40: +case 0x1C50: +case 0x2070: +case 0x2080: +case 0x2189: +case 0x24EA: +case 0x24FF: +case 0x3007: +case 0x6D1E: +case 0x96F6: +case 0xA620: +case 0xA6EF: +case 0xA8D0: +case 0xA900: +case 0xA9D0: +case 0xA9F0: +case 0xAA50: +case 0xABF0: +case 0xF9B2: +case 0xFF10: +case 0x1018A: +case 0x104A0: +case 0x10D30: +case 0x10D40: +case 0x11066: +case 0x110F0: +case 0x11136: +case 0x111D0: +case 0x112F0: +case 0x11450: +case 0x114D0: +case 0x11650: +case 0x116C0: +case 0x116D0: +case 0x116DA: +case 0x11730: +case 0x118E0: +case 0x11950: +case 0x11BF0: +case 0x11C50: +case 0x11D50: +case 0x11DA0: +case 0x11DE0: +case 0x11F50: +case 0x16130: +case 0x16A60: +case 0x16AC0: +case 0x16B50: +case 0x16D70: +case 0x16E80: +case 0x1CCF0: +case 0x1D2C0: +case 0x1D2E0: +case 0x1D7CE: +case 0x1D7D8: +case 0x1D7E2: +case 0x1D7EC: +case 0x1D7F6: +case 0x1E140: +case 0x1E2F0: +case 0x1E4F0: +case 0x1E5F1: +case 0x1E950: +case 0x1F100: +case 0x1F101: +case 0x1F10B: +case 0x1F10C: +case 0x1FBF0: +return (double) 0.0; +case 0x0031: +case 0x00B9: +case 0x0661: +case 0x06F1: +case 0x07C1: +case 0x0967: +case 0x09E7: +case 0x0A67: +case 0x0AE7: +case 0x0B67: +case 0x0BE7: +case 0x0C67: +case 0x0C79: +case 0x0C7C: +case 0x0CE7: +case 0x0D67: +case 0x0DE7: +case 0x0E51: +case 0x0ED1: +case 0x0F21: +case 0x1041: +case 0x1091: +case 0x1369: +case 0x17E1: +case 0x17F1: +case 0x1811: +case 0x1947: +case 0x19D1: +case 0x19DA: +case 0x1A81: +case 0x1A91: +case 0x1B51: +case 0x1BB1: +case 0x1C41: +case 0x1C51: +case 0x2081: +case 0x215F: +case 0x2160: +case 0x2170: +case 0x2460: +case 0x2474: +case 0x2488: +case 0x24F5: +case 0x2776: +case 0x2780: +case 0x278A: +case 0x3021: +case 0x3192: +case 0x3220: +case 0x3280: +case 0x4E00: +case 0x58F1: +case 0x58F9: +case 0x5E7A: +case 0x5F0C: +case 0xA621: +case 0xA6E6: +case 0xA8D1: +case 0xA901: +case 0xA9D1: +case 0xA9F1: +case 0xAA51: +case 0xABF1: +case 0xFF11: +case 0x10107: +case 0x10142: +case 0x10158: +case 0x10159: +case 0x1015A: +case 0x102E1: +case 0x10320: +case 0x103D1: +case 0x104A1: +case 0x10858: +case 0x10879: +case 0x108A7: +case 0x108FB: +case 0x10916: +case 0x109C0: +case 0x10A40: +case 0x10A7D: +case 0x10A9D: +case 0x10AEB: +case 0x10B58: +case 0x10B78: +case 0x10BA9: +case 0x10CFA: +case 0x10D31: +case 0x10D41: +case 0x10E60: +case 0x10F1D: +case 0x10F51: +case 0x10FC5: +case 0x11052: +case 0x11067: +case 0x110F1: +case 0x11137: +case 0x111D1: +case 0x111E1: +case 0x112F1: +case 0x11451: +case 0x114D1: +case 0x11651: +case 0x116C1: +case 0x116D1: +case 0x116DB: +case 0x11731: +case 0x118E1: +case 0x11951: +case 0x11BF1: +case 0x11C51: +case 0x11C5A: +case 0x11D51: +case 0x11DA1: +case 0x11DE1: +case 0x11F51: +case 0x12038: +case 0x12039: +case 0x12079: +case 0x1230B: +case 0x12415: +case 0x1241E: +case 0x1242C: +case 0x12434: +case 0x1244F: +case 0x12458: +case 0x16131: +case 0x16A61: +case 0x16AC1: +case 0x16B51: +case 0x16D71: +case 0x16E81: +case 0x16E94: +case 0x16FF4: +case 0x1CCF1: +case 0x1D2C1: +case 0x1D2E1: +case 0x1D360: +case 0x1D372: +case 0x1D377: +case 0x1D7CF: +case 0x1D7D9: +case 0x1D7E3: +case 0x1D7ED: +case 0x1D7F7: +case 0x1E141: +case 0x1E2F1: +case 0x1E4F1: +case 0x1E5F2: +case 0x1E8C7: +case 0x1E951: +case 0x1EC71: +case 0x1ECA3: +case 0x1ECB1: +case 0x1ED01: +case 0x1F102: +case 0x1FBF1: +case 0x2092A: +return (double) 1.0; +case 0x0D5C: +case 0x2152: +case 0x11FCB: +return (double) 1.0/10.0; +case 0x109F6: +return (double) 1.0/12.0; +case 0x09F4: +case 0x0B75: +case 0x0D76: +case 0xA833: +case 0x11FC9: +case 0x11FCA: +return (double) 1.0/16.0; +case 0x0D58: +case 0x11FC1: +return (double) 1.0/160.0; +case 0x00BD: +case 0x0B73: +case 0x0D74: +case 0x0F2A: +case 0x2CFD: +case 0xA831: +case 0x10141: +case 0x10175: +case 0x10176: +case 0x109BD: +case 0x10A48: +case 0x10E7B: +case 0x10F26: +case 0x11FD1: +case 0x11FD2: +case 0x12226: +case 0x12464: +case 0x1ECAE: +case 0x1ED3C: +return (double) 1.0/2.0; +case 0x0D5B: +case 0x11FC8: +return (double) 1.0/20.0; +case 0x2153: +case 0x10E7D: +case 0x1245A: +case 0x1245D: +case 0x12465: +return (double) 1.0/3.0; +case 0x11FC5: +return (double) 1.0/32.0; +case 0x11FC0: +case 0x11FD4: +return (double) 1.0/320.0; +case 0x00BC: +case 0x09F7: +case 0x0B72: +case 0x0D73: +case 0xA830: +case 0x10140: +case 0x1018B: +case 0x10E7C: +case 0x11FD0: +case 0x12460: +case 0x12462: +case 0x12463: +case 0x1ECAD: +return (double) 1.0/4.0; +case 0x0D59: +case 0x11FC4: +return (double) 1.0/40.0; +case 0x0D5E: +case 0x2155: +case 0x11FCF: +return (double) 1.0/5.0; +case 0x2159: +case 0x12461: +case 0x1ED3D: +return (double) 1.0/6.0; +case 0x11FC3: +return (double) 1.0/64.0; +case 0x2150: +return (double) 1.0/7.0; +case 0x09F5: +case 0x0B76: +case 0x0D77: +case 0x215B: +case 0xA834: +case 0x11FCC: +case 0x1245F: +return (double) 1.0/8.0; +case 0x11FC2: +return (double) 1.0/80.0; +case 0x2151: +return (double) 1.0/9.0; +case 0x0BF0: +case 0x0D70: +case 0x1372: +case 0x2169: +case 0x2179: +case 0x2469: +case 0x247D: +case 0x2491: +case 0x24FE: +case 0x277F: +case 0x2789: +case 0x2793: +case 0x3038: +case 0x3229: +case 0x3248: +case 0x3289: +case 0x4EC0: +case 0x5341: +case 0x62FE: +case 0xF973: +case 0xF9FD: +case 0x10110: +case 0x10149: +case 0x10150: +case 0x10157: +case 0x10160: +case 0x10161: +case 0x10162: +case 0x10163: +case 0x10164: +case 0x102EA: +case 0x10322: +case 0x103D3: +case 0x1085B: +case 0x1087E: +case 0x108AD: +case 0x108FD: +case 0x10917: +case 0x109C9: +case 0x10A44: +case 0x10A9E: +case 0x10AED: +case 0x10B5C: +case 0x10B7C: +case 0x10BAD: +case 0x10CFC: +case 0x10E69: +case 0x10F22: +case 0x10F52: +case 0x10FC9: +case 0x1105B: +case 0x111EA: +case 0x1173A: +case 0x118EA: +case 0x11C63: +case 0x16B5B: +case 0x16E8A: +case 0x1D2CA: +case 0x1D2EA: +case 0x1D369: +case 0x1EC7A: +case 0x1ED0A: +case 0x1ED37: +return (double) 10.0; +case 0x109FF: +return (double) 10.0/12.0; +case 0x0BF1: +case 0x0D71: +case 0x137B: +case 0x216D: +case 0x217D: +case 0x4F70: +case 0x767E: +case 0x964C: +case 0x10119: +case 0x1014B: +case 0x10152: +case 0x1016A: +case 0x102F3: +case 0x103D5: +case 0x1085D: +case 0x108AF: +case 0x108FF: +case 0x10919: +case 0x109D2: +case 0x10A46: +case 0x10AEF: +case 0x10B5E: +case 0x10B7E: +case 0x10BAF: +case 0x10CFE: +case 0x10E72: +case 0x10F25: +case 0x10F54: +case 0x10FCB: +case 0x11064: +case 0x111F3: +case 0x11C6C: +case 0x16B5C: +case 0x1EC83: +case 0x1ED13: +return (double) 100.0; +case 0x0BF2: +case 0x0D72: +case 0x216F: +case 0x217F: +case 0x2180: +case 0x4EDF: +case 0x5343: +case 0x9621: +case 0x10122: +case 0x1014D: +case 0x10154: +case 0x10171: +case 0x1085E: +case 0x109DB: +case 0x10A47: +case 0x10B5F: +case 0x10B7F: +case 0x10CFF: +case 0x11065: +case 0x111F4: +case 0x1EC8C: +case 0x1ED1C: +return (double) 1000.0; +case 0x137C: +case 0x2182: +case 0x4E07: +case 0x842C: +case 0x1012B: +case 0x10155: +case 0x1085F: +case 0x109E4: +case 0x16B5D: +case 0x1EC95: +case 0x1ECB3: +case 0x1ED25: +case 0x1ED3B: +return (double) 10000.0; +case 0x2188: +case 0x109ED: +case 0x1EC9E: +case 0x1ECA0: +case 0x1ECB4: +return (double) 100000.0; +case 0x16B5E: +return (double) 1000000.0; +case 0x1ECA1: +return (double) 10000000.0; +case 0x4EBF: +case 0x5104: +case 0x16B5F: +return (double) 100000000.0; +case 0x79ED: +return (double) 1000000000.0; +case 0x16B60: +return (double) 10000000000.0; +case 0x5146: +case 0x16B61: +return (double) 1000000000000.0; +case 0x4EAC: +return (double) 1e+16; +case 0x216A: +case 0x217A: +case 0x246A: +case 0x247E: +case 0x2492: +case 0x24EB: +case 0x16E8B: +case 0x1D2CB: +case 0x1D2EB: +return (double) 11.0; +case 0x109BC: +return (double) 11.0/12.0; +case 0x0F2F: +return (double) 11.0/2.0; +case 0x216B: +case 0x217B: +case 0x246B: +case 0x247F: +case 0x2493: +case 0x24EC: +case 0x16E8C: +case 0x1D2CC: +case 0x1D2EC: +return (double) 12.0; +case 0x246C: +case 0x2480: +case 0x2494: +case 0x24ED: +case 0x16E8D: +case 0x1D2CD: +case 0x1D2ED: +return (double) 13.0; +case 0x0F30: +return (double) 13.0/2.0; +case 0x246D: +case 0x2481: +case 0x2495: +case 0x24EE: +case 0x16E8E: +case 0x1D2CE: +case 0x1D2EE: +return (double) 14.0; +case 0x246E: +case 0x2482: +case 0x2496: +case 0x24EF: +case 0x16E8F: +case 0x1D2CF: +case 0x1D2EF: +return (double) 15.0; +case 0x0F31: +return (double) 15.0/2.0; +case 0x09F9: +case 0x246F: +case 0x2483: +case 0x2497: +case 0x24F0: +case 0x16E90: +case 0x1D2D0: +case 0x1D2F0: +return (double) 16.0; +case 0x16EE: +case 0x2470: +case 0x2484: +case 0x2498: +case 0x24F1: +case 0x16E91: +case 0x1D2D1: +case 0x1D2F1: +return (double) 17.0; +case 0x0F32: +return (double) 17.0/2.0; +case 0x16EF: +case 0x2471: +case 0x2485: +case 0x2499: +case 0x24F2: +case 0x16E92: +case 0x1D2D2: +case 0x1D2F2: +return (double) 18.0; +case 0x16F0: +case 0x2472: +case 0x2486: +case 0x249A: +case 0x24F3: +case 0x16E93: +case 0x1D2D3: +case 0x1D2F3: +return (double) 19.0; +case 0x0032: +case 0x00B2: +case 0x0662: +case 0x06F2: +case 0x07C2: +case 0x0968: +case 0x09E8: +case 0x0A68: +case 0x0AE8: +case 0x0B68: +case 0x0BE8: +case 0x0C68: +case 0x0C7A: +case 0x0C7D: +case 0x0CE8: +case 0x0D68: +case 0x0DE8: +case 0x0E52: +case 0x0ED2: +case 0x0F22: +case 0x1042: +case 0x1092: +case 0x136A: +case 0x17E2: +case 0x17F2: +case 0x1812: +case 0x1948: +case 0x19D2: +case 0x1A82: +case 0x1A92: +case 0x1B52: +case 0x1BB2: +case 0x1C42: +case 0x1C52: +case 0x2082: +case 0x2161: +case 0x2171: +case 0x2461: +case 0x2475: +case 0x2489: +case 0x24F6: +case 0x2777: +case 0x2781: +case 0x278B: +case 0x3022: +case 0x3193: +case 0x3221: +case 0x3281: +case 0x3483: +case 0x4E24: +case 0x4E8C: +case 0x4FE9: +case 0x5006: +case 0x5169: +case 0x5F0D: +case 0x5F10: +case 0x8CAE: +case 0x8CB3: +case 0x8D30: +case 0xA622: +case 0xA6E7: +case 0xA8D2: +case 0xA902: +case 0xA9D2: +case 0xA9F2: +case 0xAA52: +case 0xABF2: +case 0xF978: +case 0xFF12: +case 0x10108: +case 0x1015B: +case 0x1015C: +case 0x1015D: +case 0x1015E: +case 0x102E2: +case 0x103D2: +case 0x104A2: +case 0x10859: +case 0x1087A: +case 0x108A8: +case 0x1091A: +case 0x109C1: +case 0x10A41: +case 0x10B59: +case 0x10B79: +case 0x10BAA: +case 0x10D32: +case 0x10D42: +case 0x10E61: +case 0x10F1E: +case 0x10FC6: +case 0x11053: +case 0x11068: +case 0x110F2: +case 0x11138: +case 0x111D2: +case 0x111E2: +case 0x112F2: +case 0x11452: +case 0x114D2: +case 0x11652: +case 0x116C2: +case 0x116D2: +case 0x116DC: +case 0x11732: +case 0x118E2: +case 0x11952: +case 0x11BF2: +case 0x11C52: +case 0x11C5B: +case 0x11D52: +case 0x11DA2: +case 0x11DE2: +case 0x11F52: +case 0x1222B: +case 0x12399: +case 0x12400: +case 0x12416: +case 0x1241F: +case 0x12423: +case 0x1242D: +case 0x12435: +case 0x1244A: +case 0x12450: +case 0x12456: +case 0x12459: +case 0x16132: +case 0x16A62: +case 0x16AC2: +case 0x16B52: +case 0x16D72: +case 0x16E82: +case 0x16E95: +case 0x16FF6: +case 0x1CCF2: +case 0x1D2C2: +case 0x1D2E2: +case 0x1D361: +case 0x1D373: +case 0x1D7D0: +case 0x1D7DA: +case 0x1D7E4: +case 0x1D7EE: +case 0x1D7F8: +case 0x1E142: +case 0x1E2F2: +case 0x1E4F2: +case 0x1E5F3: +case 0x1E8C8: +case 0x1E952: +case 0x1EC72: +case 0x1ECA4: +case 0x1ECB2: +case 0x1ED02: +case 0x1ED2F: +case 0x1F103: +case 0x1FBF2: +case 0x22390: +return (double) 2.0; +case 0x109F7: +return (double) 2.0/12.0; +case 0x2154: +case 0x10177: +case 0x10E7E: +case 0x1245B: +case 0x1245E: +case 0x12466: +return (double) 2.0/3.0; +case 0x2156: +return (double) 2.0/5.0; +case 0x1373: +case 0x2473: +case 0x2487: +case 0x249B: +case 0x24F4: +case 0x3039: +case 0x3249: +case 0x5344: +case 0x5EFF: +case 0x10111: +case 0x102EB: +case 0x103D4: +case 0x1085C: +case 0x1087F: +case 0x108AE: +case 0x108FE: +case 0x10918: +case 0x109CA: +case 0x10A45: +case 0x10A9F: +case 0x10AEE: +case 0x10B5D: +case 0x10B7D: +case 0x10BAE: +case 0x10E6A: +case 0x10F23: +case 0x10F53: +case 0x10FCA: +case 0x1105C: +case 0x111EB: +case 0x1173B: +case 0x118EB: +case 0x11C64: +case 0x1D36A: +case 0x1EC7B: +case 0x1ED0B: +return (double) 20.0; +case 0x7695: +case 0x1011A: +case 0x102F4: +case 0x109D3: +case 0x10E73: +case 0x1EC84: +case 0x1ED14: +return (double) 200.0; +case 0x10123: +case 0x109DC: +case 0x1EC8D: +case 0x1ED1D: +case 0x1ED3A: +return (double) 2000.0; +case 0x1012C: +case 0x109E5: +case 0x1EC96: +case 0x1ED26: +return (double) 20000.0; +case 0x109EE: +case 0x1EC9F: +return (double) 200000.0; +case 0x1ECA2: +return (double) 20000000.0; +case 0x3251: +return (double) 21.0; +case 0x12432: +return (double) 216000.0; +case 0x3252: +return (double) 22.0; +case 0x3253: +return (double) 23.0; +case 0x3254: +return (double) 24.0; +case 0x3255: +return (double) 25.0; +case 0x3256: +return (double) 26.0; +case 0x3257: +return (double) 27.0; +case 0x3258: +return (double) 28.0; +case 0x3259: +return (double) 29.0; +case 0x0033: +case 0x00B3: +case 0x0663: +case 0x06F3: +case 0x07C3: +case 0x0969: +case 0x09E9: +case 0x0A69: +case 0x0AE9: +case 0x0B69: +case 0x0BE9: +case 0x0C69: +case 0x0C7B: +case 0x0C7E: +case 0x0CE9: +case 0x0D69: +case 0x0DE9: +case 0x0E53: +case 0x0ED3: +case 0x0F23: +case 0x1043: +case 0x1093: +case 0x136B: +case 0x17E3: +case 0x17F3: +case 0x1813: +case 0x1949: +case 0x19D3: +case 0x1A83: +case 0x1A93: +case 0x1B53: +case 0x1BB3: +case 0x1C43: +case 0x1C53: +case 0x2083: +case 0x2162: +case 0x2172: +case 0x2462: +case 0x2476: +case 0x248A: +case 0x24F7: +case 0x2778: +case 0x2782: +case 0x278C: +case 0x3023: +case 0x3194: +case 0x3222: +case 0x3282: +case 0x4E09: +case 0x4EE8: +case 0x53C1: +case 0x53C2: +case 0x53C3: +case 0x53C4: +case 0x5F0E: +case 0xA623: +case 0xA6E8: +case 0xA8D3: +case 0xA903: +case 0xA9D3: +case 0xA9F3: +case 0xAA53: +case 0xABF3: +case 0xF96B: +case 0xFF13: +case 0x10109: +case 0x102E3: +case 0x104A3: +case 0x1085A: +case 0x1087B: +case 0x108A9: +case 0x1091B: +case 0x109C2: +case 0x10A42: +case 0x10B5A: +case 0x10B7A: +case 0x10BAB: +case 0x10D33: +case 0x10D43: +case 0x10E62: +case 0x10F1F: +case 0x10FC7: +case 0x11054: +case 0x11069: +case 0x110F3: +case 0x11139: +case 0x111D3: +case 0x111E3: +case 0x112F3: +case 0x11453: +case 0x114D3: +case 0x11653: +case 0x116C3: +case 0x116D3: +case 0x116DD: +case 0x11733: +case 0x118E3: +case 0x11953: +case 0x11BF3: +case 0x11C53: +case 0x11C5C: +case 0x11D53: +case 0x11DA3: +case 0x11DE3: +case 0x11F53: +case 0x1230D: +case 0x12401: +case 0x12408: +case 0x12417: +case 0x12420: +case 0x12424: +case 0x12425: +case 0x1242E: +case 0x1242F: +case 0x12436: +case 0x12437: +case 0x1243A: +case 0x1243B: +case 0x1244B: +case 0x12451: +case 0x12457: +case 0x16133: +case 0x16A63: +case 0x16AC3: +case 0x16B53: +case 0x16D73: +case 0x16E83: +case 0x16E96: +case 0x1CCF3: +case 0x1D2C3: +case 0x1D2E3: +case 0x1D362: +case 0x1D374: +case 0x1D7D1: +case 0x1D7DB: +case 0x1D7E5: +case 0x1D7EF: +case 0x1D7F9: +case 0x1E143: +case 0x1E2F3: +case 0x1E4F3: +case 0x1E5F4: +case 0x1E8C9: +case 0x1E953: +case 0x1EC73: +case 0x1ECA5: +case 0x1ED03: +case 0x1ED30: +case 0x1F104: +case 0x1FBF3: +case 0x20AFD: +case 0x20B19: +case 0x22998: +case 0x23B1B: +return (double) 3.0; +case 0x109F8: +return (double) 3.0/12.0; +case 0x09F6: +case 0x0B77: +case 0x0D78: +case 0xA835: +case 0x11FCE: +return (double) 3.0/16.0; +case 0x0F2B: +case 0x16FF5: +return (double) 3.0/2.0; +case 0x0D5D: +case 0x11FCD: +return (double) 3.0/20.0; +case 0x00BE: +case 0x09F8: +case 0x0B74: +case 0x0D75: +case 0xA832: +case 0x10178: +case 0x11FD3: +case 0x1ECAF: +return (double) 3.0/4.0; +case 0x2157: +return (double) 3.0/5.0; +case 0x11FC7: +return (double) 3.0/64.0; +case 0x215C: +return (double) 3.0/8.0; +case 0x0D5A: +case 0x11FC6: +return (double) 3.0/80.0; +case 0x1374: +case 0x303A: +case 0x324A: +case 0x325A: +case 0x5345: +case 0x10112: +case 0x10165: +case 0x102EC: +case 0x109CB: +case 0x10E6B: +case 0x10F24: +case 0x1105D: +case 0x111EC: +case 0x118EC: +case 0x11C65: +case 0x1D36B: +case 0x1EC7C: +case 0x1ED0C: +case 0x20983: +return (double) 30.0; +case 0x1011B: +case 0x1016B: +case 0x102F5: +case 0x109D4: +case 0x10E74: +case 0x1EC85: +case 0x1ED15: +return (double) 300.0; +case 0x10124: +case 0x109DD: +case 0x1EC8E: +case 0x1ED1E: +return (double) 3000.0; +case 0x1012D: +case 0x109E6: +case 0x1EC97: +case 0x1ED27: +return (double) 30000.0; +case 0x109EF: +return (double) 300000.0; +case 0x325B: +return (double) 31.0; +case 0x325C: +return (double) 32.0; +case 0x325D: +return (double) 33.0; +case 0x325E: +return (double) 34.0; +case 0x325F: +return (double) 35.0; +case 0x32B1: +return (double) 36.0; +case 0x32B2: +return (double) 37.0; +case 0x32B3: +return (double) 38.0; +case 0x32B4: +return (double) 39.0; +case 0x0034: +case 0x0664: +case 0x06F4: +case 0x07C4: +case 0x096A: +case 0x09EA: +case 0x0A6A: +case 0x0AEA: +case 0x0B6A: +case 0x0BEA: +case 0x0C6A: +case 0x0CEA: +case 0x0D6A: +case 0x0DEA: +case 0x0E54: +case 0x0ED4: +case 0x0F24: +case 0x1044: +case 0x1094: +case 0x136C: +case 0x17E4: +case 0x17F4: +case 0x1814: +case 0x194A: +case 0x19D4: +case 0x1A84: +case 0x1A94: +case 0x1B54: +case 0x1BB4: +case 0x1C44: +case 0x1C54: +case 0x2074: +case 0x2084: +case 0x2163: +case 0x2173: +case 0x2463: +case 0x2477: +case 0x248B: +case 0x24F8: +case 0x2779: +case 0x2783: +case 0x278D: +case 0x3024: +case 0x3195: +case 0x3223: +case 0x3283: +case 0x4E96: +case 0x56DB: +case 0x8086: +case 0xA624: +case 0xA6E9: +case 0xA8D4: +case 0xA904: +case 0xA9D4: +case 0xA9F4: +case 0xAA54: +case 0xABF4: +case 0xFF14: +case 0x1010A: +case 0x102E4: +case 0x104A4: +case 0x1087C: +case 0x108AA: +case 0x108AB: +case 0x109C3: +case 0x10A43: +case 0x10B5B: +case 0x10B7B: +case 0x10BAC: +case 0x10D34: +case 0x10D44: +case 0x10E63: +case 0x10F20: +case 0x10FC8: +case 0x11055: +case 0x1106A: +case 0x110F4: +case 0x1113A: +case 0x111D4: +case 0x111E4: +case 0x112F4: +case 0x11454: +case 0x114D4: +case 0x11654: +case 0x116C4: +case 0x116D4: +case 0x116DE: +case 0x11734: +case 0x118E4: +case 0x11954: +case 0x11BF4: +case 0x11C54: +case 0x11C5D: +case 0x11D54: +case 0x11DA4: +case 0x11DE4: +case 0x11F54: +case 0x12402: +case 0x12409: +case 0x1240F: +case 0x12418: +case 0x12421: +case 0x12426: +case 0x12430: +case 0x12438: +case 0x1243C: +case 0x1243D: +case 0x1243E: +case 0x1243F: +case 0x1244C: +case 0x12452: +case 0x12453: +case 0x12469: +case 0x16134: +case 0x16A64: +case 0x16AC4: +case 0x16B54: +case 0x16D74: +case 0x16E84: +case 0x1CCF4: +case 0x1D2C4: +case 0x1D2E4: +case 0x1D363: +case 0x1D375: +case 0x1D7D2: +case 0x1D7DC: +case 0x1D7E6: +case 0x1D7F0: +case 0x1D7FA: +case 0x1E144: +case 0x1E2F4: +case 0x1E4F4: +case 0x1E5F5: +case 0x1E8CA: +case 0x1E954: +case 0x1EC74: +case 0x1ECA6: +case 0x1ED04: +case 0x1ED31: +case 0x1F105: +case 0x1FBF4: +case 0x20064: +case 0x200E2: +case 0x2626D: +return (double) 4.0; +case 0x109F9: +return (double) 4.0/12.0; +case 0x2158: +return (double) 4.0/5.0; +case 0x1375: +case 0x324B: +case 0x32B5: +case 0x534C: +case 0x10113: +case 0x102ED: +case 0x109CC: +case 0x10E6C: +case 0x1105E: +case 0x111ED: +case 0x118ED: +case 0x11C66: +case 0x12467: +case 0x1D36C: +case 0x1EC7D: +case 0x1ED0D: +case 0x2098C: +case 0x2099C: +return (double) 40.0; +case 0x1011C: +case 0x102F6: +case 0x109D5: +case 0x10E75: +case 0x1EC86: +case 0x1ED16: +case 0x1ED38: +return (double) 400.0; +case 0x10125: +case 0x109DE: +case 0x1EC8F: +case 0x1ED1F: +return (double) 4000.0; +case 0x1012E: +case 0x109E7: +case 0x1EC98: +case 0x1ED28: +return (double) 40000.0; +case 0x109F0: +return (double) 400000.0; +case 0x32B6: +return (double) 41.0; +case 0x32B7: +return (double) 42.0; +case 0x32B8: +return (double) 43.0; +case 0x12433: +return (double) 432000.0; +case 0x32B9: +return (double) 44.0; +case 0x32BA: +return (double) 45.0; +case 0x32BB: +return (double) 46.0; +case 0x32BC: +return (double) 47.0; +case 0x32BD: +return (double) 48.0; +case 0x32BE: +return (double) 49.0; +case 0x0035: +case 0x0665: +case 0x06F5: +case 0x07C5: +case 0x096B: +case 0x09EB: +case 0x0A6B: +case 0x0AEB: +case 0x0B6B: +case 0x0BEB: +case 0x0C6B: +case 0x0CEB: +case 0x0D6B: +case 0x0DEB: +case 0x0E55: +case 0x0ED5: +case 0x0F25: +case 0x1045: +case 0x1095: +case 0x136D: +case 0x17E5: +case 0x17F5: +case 0x1815: +case 0x194B: +case 0x19D5: +case 0x1A85: +case 0x1A95: +case 0x1B55: +case 0x1BB5: +case 0x1C45: +case 0x1C55: +case 0x2075: +case 0x2085: +case 0x2164: +case 0x2174: +case 0x2464: +case 0x2478: +case 0x248C: +case 0x24F9: +case 0x277A: +case 0x2784: +case 0x278E: +case 0x3025: +case 0x3224: +case 0x3284: +case 0x3405: +case 0x382A: +case 0x4E94: +case 0x4F0D: +case 0xA625: +case 0xA6EA: +case 0xA8D5: +case 0xA905: +case 0xA9D5: +case 0xA9F5: +case 0xAA55: +case 0xABF5: +case 0xFF15: +case 0x1010B: +case 0x10143: +case 0x10148: +case 0x1014F: +case 0x1015F: +case 0x10173: +case 0x102E5: +case 0x10321: +case 0x104A5: +case 0x1087D: +case 0x108AC: +case 0x108FC: +case 0x109C4: +case 0x10AEC: +case 0x10CFB: +case 0x10D35: +case 0x10D45: +case 0x10E64: +case 0x10F21: +case 0x11056: +case 0x1106B: +case 0x110F5: +case 0x1113B: +case 0x111D5: +case 0x111E5: +case 0x112F5: +case 0x11455: +case 0x114D5: +case 0x11655: +case 0x116C5: +case 0x116D5: +case 0x116DF: +case 0x11735: +case 0x118E5: +case 0x11955: +case 0x11BF5: +case 0x11C55: +case 0x11C5E: +case 0x11D55: +case 0x11DA5: +case 0x11DE5: +case 0x11F55: +case 0x12403: +case 0x1240A: +case 0x12410: +case 0x12419: +case 0x12422: +case 0x12427: +case 0x12431: +case 0x12439: +case 0x1244D: +case 0x12454: +case 0x12455: +case 0x1246A: +case 0x16135: +case 0x16A65: +case 0x16AC5: +case 0x16B55: +case 0x16D75: +case 0x16E85: +case 0x1CCF5: +case 0x1D2C5: +case 0x1D2E5: +case 0x1D364: +case 0x1D376: +case 0x1D378: +case 0x1D7D3: +case 0x1D7DD: +case 0x1D7E7: +case 0x1D7F1: +case 0x1D7FB: +case 0x1E145: +case 0x1E2F5: +case 0x1E4F5: +case 0x1E5F6: +case 0x1E8CB: +case 0x1E955: +case 0x1EC75: +case 0x1ECA7: +case 0x1ED05: +case 0x1ED32: +case 0x1F106: +case 0x1FBF5: +case 0x20121: +return (double) 5.0; +case 0x109FA: +return (double) 5.0/12.0; +case 0x0F2C: +return (double) 5.0/2.0; +case 0x215A: +case 0x1245C: +return (double) 5.0/6.0; +case 0x215D: +return (double) 5.0/8.0; +case 0x1376: +case 0x216C: +case 0x217C: +case 0x2186: +case 0x324C: +case 0x32BF: +case 0x10114: +case 0x10144: +case 0x1014A: +case 0x10151: +case 0x10166: +case 0x10167: +case 0x10168: +case 0x10169: +case 0x10174: +case 0x102EE: +case 0x10323: +case 0x109CD: +case 0x10A7E: +case 0x10CFD: +case 0x10E6D: +case 0x1105F: +case 0x111EE: +case 0x118EE: +case 0x11C67: +case 0x12468: +case 0x1D36D: +case 0x1EC7E: +case 0x1ED0E: +return (double) 50.0; +case 0x216E: +case 0x217E: +case 0x1011D: +case 0x10145: +case 0x1014C: +case 0x10153: +case 0x1016C: +case 0x1016D: +case 0x1016E: +case 0x1016F: +case 0x10170: +case 0x102F7: +case 0x109D6: +case 0x10E76: +case 0x1EC87: +case 0x1ED17: +return (double) 500.0; +case 0x2181: +case 0x10126: +case 0x10146: +case 0x1014E: +case 0x10172: +case 0x109DF: +case 0x1EC90: +case 0x1ED20: +return (double) 5000.0; +case 0x2187: +case 0x1012F: +case 0x10147: +case 0x10156: +case 0x109E8: +case 0x1EC99: +case 0x1ED29: +return (double) 50000.0; +case 0x109F1: +return (double) 500000.0; +case 0x0036: +case 0x0666: +case 0x06F6: +case 0x07C6: +case 0x096C: +case 0x09EC: +case 0x0A6C: +case 0x0AEC: +case 0x0B6C: +case 0x0BEC: +case 0x0C6C: +case 0x0CEC: +case 0x0D6C: +case 0x0DEC: +case 0x0E56: +case 0x0ED6: +case 0x0F26: +case 0x1046: +case 0x1096: +case 0x136E: +case 0x17E6: +case 0x17F6: +case 0x1816: +case 0x194C: +case 0x19D6: +case 0x1A86: +case 0x1A96: +case 0x1B56: +case 0x1BB6: +case 0x1C46: +case 0x1C56: +case 0x2076: +case 0x2086: +case 0x2165: +case 0x2175: +case 0x2185: +case 0x2465: +case 0x2479: +case 0x248D: +case 0x24FA: +case 0x277B: +case 0x2785: +case 0x278F: +case 0x3026: +case 0x3225: +case 0x3285: +case 0x516D: +case 0x9646: +case 0x9678: +case 0xA626: +case 0xA6EB: +case 0xA8D6: +case 0xA906: +case 0xA9D6: +case 0xA9F6: +case 0xAA56: +case 0xABF6: +case 0xF9D1: +case 0xF9D3: +case 0xFF16: +case 0x1010C: +case 0x102E6: +case 0x104A6: +case 0x109C5: +case 0x10D36: +case 0x10D46: +case 0x10E65: +case 0x11057: +case 0x1106C: +case 0x110F6: +case 0x1113C: +case 0x111D6: +case 0x111E6: +case 0x112F6: +case 0x11456: +case 0x114D6: +case 0x11656: +case 0x116C6: +case 0x116D6: +case 0x116E0: +case 0x11736: +case 0x118E6: +case 0x11956: +case 0x11BF6: +case 0x11C56: +case 0x11C5F: +case 0x11D56: +case 0x11DA6: +case 0x11DE6: +case 0x11F56: +case 0x12404: +case 0x1240B: +case 0x12411: +case 0x1241A: +case 0x12428: +case 0x12440: +case 0x1244E: +case 0x1246B: +case 0x16136: +case 0x16A66: +case 0x16AC6: +case 0x16B56: +case 0x16D76: +case 0x16E86: +case 0x1CCF6: +case 0x1D2C6: +case 0x1D2E6: +case 0x1D365: +case 0x1D7D4: +case 0x1D7DE: +case 0x1D7E8: +case 0x1D7F2: +case 0x1D7FC: +case 0x1E146: +case 0x1E2F6: +case 0x1E4F6: +case 0x1E5F7: +case 0x1E8CC: +case 0x1E956: +case 0x1EC76: +case 0x1ECA8: +case 0x1ED06: +case 0x1ED33: +case 0x1F107: +case 0x1FBF6: +case 0x20AEA: +return (double) 6.0; +case 0x109FB: +return (double) 6.0/12.0; +case 0x1377: +case 0x324D: +case 0x10115: +case 0x102EF: +case 0x109CE: +case 0x10E6E: +case 0x11060: +case 0x111EF: +case 0x118EF: +case 0x11C68: +case 0x1D36E: +case 0x1EC7F: +case 0x1ED0F: +return (double) 60.0; +case 0x1011E: +case 0x102F8: +case 0x109D7: +case 0x10E77: +case 0x1EC88: +case 0x1ED18: +case 0x1ED39: +return (double) 600.0; +case 0x10127: +case 0x109E0: +case 0x1EC91: +case 0x1ED21: +return (double) 6000.0; +case 0x10130: +case 0x109E9: +case 0x1EC9A: +case 0x1ED2A: +return (double) 60000.0; +case 0x109F2: +return (double) 600000.0; +case 0x0037: +case 0x0667: +case 0x06F7: +case 0x07C7: +case 0x096D: +case 0x09ED: +case 0x0A6D: +case 0x0AED: +case 0x0B6D: +case 0x0BED: +case 0x0C6D: +case 0x0CED: +case 0x0D6D: +case 0x0DED: +case 0x0E57: +case 0x0ED7: +case 0x0F27: +case 0x1047: +case 0x1097: +case 0x136F: +case 0x17E7: +case 0x17F7: +case 0x1817: +case 0x194D: +case 0x19D7: +case 0x1A87: +case 0x1A97: +case 0x1B57: +case 0x1BB7: +case 0x1C47: +case 0x1C57: +case 0x2077: +case 0x2087: +case 0x2166: +case 0x2176: +case 0x2466: +case 0x247A: +case 0x248E: +case 0x24FB: +case 0x277C: +case 0x2786: +case 0x2790: +case 0x3027: +case 0x3226: +case 0x3286: +case 0x3B4D: +case 0x4E03: +case 0x62D0: +case 0x67D2: +case 0x6F06: +case 0xA627: +case 0xA6EC: +case 0xA8D7: +case 0xA907: +case 0xA9D7: +case 0xA9F7: +case 0xAA57: +case 0xABF7: +case 0xFF17: +case 0x1010D: +case 0x102E7: +case 0x104A7: +case 0x109C6: +case 0x10D37: +case 0x10D47: +case 0x10E66: +case 0x11058: +case 0x1106D: +case 0x110F7: +case 0x1113D: +case 0x111D7: +case 0x111E7: +case 0x112F7: +case 0x11457: +case 0x114D7: +case 0x11657: +case 0x116C7: +case 0x116D7: +case 0x116E1: +case 0x11737: +case 0x118E7: +case 0x11957: +case 0x11BF7: +case 0x11C57: +case 0x11C60: +case 0x11D57: +case 0x11DA7: +case 0x11DE7: +case 0x11F57: +case 0x12405: +case 0x1240C: +case 0x12412: +case 0x1241B: +case 0x12429: +case 0x12441: +case 0x12442: +case 0x12443: +case 0x1246C: +case 0x16137: +case 0x16A67: +case 0x16AC7: +case 0x16B57: +case 0x16D77: +case 0x16E87: +case 0x1CCF7: +case 0x1D2C7: +case 0x1D2E7: +case 0x1D366: +case 0x1D7D5: +case 0x1D7DF: +case 0x1D7E9: +case 0x1D7F3: +case 0x1D7FD: +case 0x1E147: +case 0x1E2F7: +case 0x1E4F7: +case 0x1E5F8: +case 0x1E8CD: +case 0x1E957: +case 0x1EC77: +case 0x1ECA9: +case 0x1ED07: +case 0x1ED34: +case 0x1F108: +case 0x1FBF7: +case 0x20001: +return (double) 7.0; +case 0x109FC: +return (double) 7.0/12.0; +case 0x0F2D: +return (double) 7.0/2.0; +case 0x215E: +return (double) 7.0/8.0; +case 0x1378: +case 0x324E: +case 0x10116: +case 0x102F0: +case 0x109CF: +case 0x10E6F: +case 0x11061: +case 0x111F0: +case 0x118F0: +case 0x11C69: +case 0x1D36F: +case 0x1EC80: +case 0x1ED10: +return (double) 70.0; +case 0x1011F: +case 0x102F9: +case 0x109D8: +case 0x10E78: +case 0x1EC89: +case 0x1ED19: +return (double) 700.0; +case 0x10128: +case 0x109E1: +case 0x1EC92: +case 0x1ED22: +return (double) 7000.0; +case 0x10131: +case 0x109EA: +case 0x1EC9B: +case 0x1ED2B: +return (double) 70000.0; +case 0x109F3: +return (double) 700000.0; +case 0x0038: +case 0x0668: +case 0x06F8: +case 0x07C8: +case 0x096E: +case 0x09EE: +case 0x0A6E: +case 0x0AEE: +case 0x0B6E: +case 0x0BEE: +case 0x0C6E: +case 0x0CEE: +case 0x0D6E: +case 0x0DEE: +case 0x0E58: +case 0x0ED8: +case 0x0F28: +case 0x1048: +case 0x1098: +case 0x1370: +case 0x17E8: +case 0x17F8: +case 0x1818: +case 0x194E: +case 0x19D8: +case 0x1A88: +case 0x1A98: +case 0x1B58: +case 0x1BB8: +case 0x1C48: +case 0x1C58: +case 0x2078: +case 0x2088: +case 0x2167: +case 0x2177: +case 0x2467: +case 0x247B: +case 0x248F: +case 0x24FC: +case 0x277D: +case 0x2787: +case 0x2791: +case 0x3028: +case 0x3227: +case 0x3287: +case 0x516B: +case 0x634C: +case 0xA628: +case 0xA6ED: +case 0xA8D8: +case 0xA908: +case 0xA9D8: +case 0xA9F8: +case 0xAA58: +case 0xABF8: +case 0xFF18: +case 0x1010E: +case 0x102E8: +case 0x104A8: +case 0x109C7: +case 0x10D38: +case 0x10D48: +case 0x10E67: +case 0x11059: +case 0x1106E: +case 0x110F8: +case 0x1113E: +case 0x111D8: +case 0x111E8: +case 0x112F8: +case 0x11458: +case 0x114D8: +case 0x11658: +case 0x116C8: +case 0x116D8: +case 0x116E2: +case 0x11738: +case 0x118E8: +case 0x11958: +case 0x11BF8: +case 0x11C58: +case 0x11C61: +case 0x11D58: +case 0x11DA8: +case 0x11DE8: +case 0x11F58: +case 0x12406: +case 0x1240D: +case 0x12413: +case 0x1241C: +case 0x1242A: +case 0x12444: +case 0x12445: +case 0x1246D: +case 0x16138: +case 0x16A68: +case 0x16AC8: +case 0x16B58: +case 0x16D78: +case 0x16E88: +case 0x1CCF8: +case 0x1D2C8: +case 0x1D2E8: +case 0x1D367: +case 0x1D7D6: +case 0x1D7E0: +case 0x1D7EA: +case 0x1D7F4: +case 0x1D7FE: +case 0x1E148: +case 0x1E2F8: +case 0x1E4F8: +case 0x1E5F9: +case 0x1E8CE: +case 0x1E958: +case 0x1EC78: +case 0x1ECAA: +case 0x1ED08: +case 0x1ED35: +case 0x1F109: +case 0x1FBF8: +return (double) 8.0; +case 0x109FD: +return (double) 8.0/12.0; +case 0x1379: +case 0x324F: +case 0x10117: +case 0x102F1: +case 0x10E70: +case 0x11062: +case 0x111F1: +case 0x118F1: +case 0x11C6A: +case 0x1D370: +case 0x1EC81: +case 0x1ED11: +return (double) 80.0; +case 0x10120: +case 0x102FA: +case 0x109D9: +case 0x10E79: +case 0x1EC8A: +case 0x1ED1A: +return (double) 800.0; +case 0x10129: +case 0x109E2: +case 0x1EC93: +case 0x1ED23: +return (double) 8000.0; +case 0x10132: +case 0x109EB: +case 0x1EC9C: +case 0x1ED2C: +return (double) 80000.0; +case 0x109F4: +return (double) 800000.0; +case 0x0039: +case 0x0669: +case 0x06F9: +case 0x07C9: +case 0x096F: +case 0x09EF: +case 0x0A6F: +case 0x0AEF: +case 0x0B6F: +case 0x0BEF: +case 0x0C6F: +case 0x0CEF: +case 0x0D6F: +case 0x0DEF: +case 0x0E59: +case 0x0ED9: +case 0x0F29: +case 0x1049: +case 0x1099: +case 0x1371: +case 0x17E9: +case 0x17F9: +case 0x1819: +case 0x194F: +case 0x19D9: +case 0x1A89: +case 0x1A99: +case 0x1B59: +case 0x1BB9: +case 0x1C49: +case 0x1C59: +case 0x2079: +case 0x2089: +case 0x2168: +case 0x2178: +case 0x2468: +case 0x247C: +case 0x2490: +case 0x24FD: +case 0x277E: +case 0x2788: +case 0x2792: +case 0x3029: +case 0x3228: +case 0x3288: +case 0x4E5D: +case 0x5EFE: +case 0x7396: +case 0x920E: +case 0x94A9: +case 0xA629: +case 0xA6EE: +case 0xA8D9: +case 0xA909: +case 0xA9D9: +case 0xA9F9: +case 0xAA59: +case 0xABF9: +case 0xFF19: +case 0x1010F: +case 0x102E9: +case 0x104A9: +case 0x109C8: +case 0x10D39: +case 0x10D49: +case 0x10E68: +case 0x1105A: +case 0x1106F: +case 0x110F9: +case 0x1113F: +case 0x111D9: +case 0x111E9: +case 0x112F9: +case 0x11459: +case 0x114D9: +case 0x11659: +case 0x116C9: +case 0x116D9: +case 0x116E3: +case 0x11739: +case 0x118E9: +case 0x11959: +case 0x11BF9: +case 0x11C59: +case 0x11C62: +case 0x11D59: +case 0x11DA9: +case 0x11DE9: +case 0x11F59: +case 0x12407: +case 0x1240E: +case 0x12414: +case 0x1241D: +case 0x1242B: +case 0x12446: +case 0x12447: +case 0x12448: +case 0x12449: +case 0x1246E: +case 0x16139: +case 0x16A69: +case 0x16AC9: +case 0x16B59: +case 0x16D79: +case 0x16E89: +case 0x1CCF9: +case 0x1D2C9: +case 0x1D2E9: +case 0x1D368: +case 0x1D7D7: +case 0x1D7E1: +case 0x1D7EB: +case 0x1D7F5: +case 0x1D7FF: +case 0x1E149: +case 0x1E2F9: +case 0x1E4F9: +case 0x1E5FA: +case 0x1E8CF: +case 0x1E959: +case 0x1EC79: +case 0x1ECAB: +case 0x1ED09: +case 0x1ED36: +case 0x1F10A: +case 0x1FBF9: +case 0x2F890: +return (double) 9.0; +case 0x109FE: +return (double) 9.0/12.0; +case 0x0F2E: +return (double) 9.0/2.0; +case 0x137A: +case 0x10118: +case 0x102F2: +case 0x10341: +case 0x10E71: +case 0x11063: +case 0x111F2: +case 0x118F2: +case 0x11C6B: +case 0x1D371: +case 0x1EC82: +case 0x1ED12: +return (double) 90.0; +case 0x10121: +case 0x102FB: +case 0x1034A: +case 0x109DA: +case 0x10E7A: +case 0x1EC8B: +case 0x1ED1B: +return (double) 900.0; +case 0x1012A: +case 0x109E3: +case 0x1EC94: +case 0x1ED24: +return (double) 9000.0; +case 0x10133: +case 0x109EC: +case 0x1EC9D: +case 0x1ED2D: +return (double) 90000.0; +case 0x109F5: +return (double) 900000.0; +} +return -1.0; +} +/* Returns 1 for Unicode characters having the bidirectional +* type 'WS', 'B' or 'S' or the category 'Zs', 0 otherwise. +*/ +int _PyUnicode_IsWhitespace(const Py_UCS4 ch) +{ +switch (ch) { +case 0x0009: +case 0x000A: +case 0x000B: +case 0x000C: +case 0x000D: +case 0x001C: +case 0x001D: +case 0x001E: +case 0x001F: +case 0x0020: +case 0x0085: +case 0x00A0: +case 0x1680: +case 0x2000: +case 0x2001: +case 0x2002: +case 0x2003: +case 0x2004: +case 0x2005: +case 0x2006: +case 0x2007: +case 0x2008: +case 0x2009: +case 0x200A: +case 0x2028: +case 0x2029: +case 0x202F: +case 0x205F: +case 0x3000: +return 1; +} +return 0; +} +/* Returns 1 for Unicode characters having the line break +* property 'BK', 'CR', 'LF' or 'NL' or having bidirectional +* type 'B', 0 otherwise. +*/ +int _PyUnicode_IsLinebreak(const Py_UCS4 ch) +{ +switch (ch) { +case 0x000A: +case 0x000B: +case 0x000C: +case 0x000D: +case 0x001C: +case 0x001D: +case 0x001E: +case 0x0085: +case 0x2028: +case 0x2029: +return 1; +} +return 0; +} + +/* +Unicode character type helpers. +Written by Marc-Andre Lemburg (mal@lemburg.com). +Modified for Python 2.0 by Fredrik Lundh (fredrik@pythonware.com) +Copyright (c) Corporation for National Research Initiatives. +*/ +#include "Python.h" +#include "pycore_unicodectype.h" // export _PyUnicode_IsXidStart(), _PyUnicode_IsXidContinue() +#define ALPHA_MASK 0x01 +#define DECIMAL_MASK 0x02 +#define DIGIT_MASK 0x04 +#define LOWER_MASK 0x08 +#define TITLE_MASK 0x40 +#define UPPER_MASK 0x80 +#define XID_START_MASK 0x100 +#define XID_CONTINUE_MASK 0x200 +#define PRINTABLE_MASK 0x400 +#define NUMERIC_MASK 0x800 +#define CASE_IGNORABLE_MASK 0x1000 +#define CASED_MASK 0x2000 +#define EXTENDED_CASE_MASK 0x4000 +typedef struct { +/* +These are either deltas to the character or offsets in +_PyUnicode_ExtendedCase. +*/ +const int upper; +const int lower; +const int title; +/* Note if more flag space is needed, decimal and digit could be unified. */ +const unsigned char decimal; +const unsigned char digit; +const unsigned short flags; +} _PyUnicode_TypeRecord; +#include "unicodetype_db.h" +static const _PyUnicode_TypeRecord * +gettyperecord(Py_UCS4 code) +{ +int index; +if (code >= 0x110000) +index = 0; +else +{ +index = index1[(code>>SHIFT)]; +index = index2[(index<flags & EXTENDED_CASE_MASK) +return _PyUnicode_ExtendedCase[ctype->title & 0xFFFF]; +return ch + ctype->title; +} +/* Returns 1 for Unicode characters having the category 'Lt', 0 +otherwise. */ +int _PyUnicode_IsTitlecase(Py_UCS4 ch) +{ +const _PyUnicode_TypeRecord *ctype = gettyperecord(ch); +return (ctype->flags & TITLE_MASK) != 0; +} +/* Returns 1 for Unicode characters having the XID_Start property, 0 +otherwise. */ +int _PyUnicode_IsXidStart(Py_UCS4 ch) +{ +const _PyUnicode_TypeRecord *ctype = gettyperecord(ch); +return (ctype->flags & XID_START_MASK) != 0; +} +/* Returns 1 for Unicode characters having the XID_Continue property, +0 otherwise. */ +int _PyUnicode_IsXidContinue(Py_UCS4 ch) +{ +const _PyUnicode_TypeRecord *ctype = gettyperecord(ch); +return (ctype->flags & XID_CONTINUE_MASK) != 0; +} +/* Returns the integer decimal (0-9) for Unicode characters having +this property, -1 otherwise. */ +int _PyUnicode_ToDecimalDigit(Py_UCS4 ch) +{ +const _PyUnicode_TypeRecord *ctype = gettyperecord(ch); +return (ctype->flags & DECIMAL_MASK) ? ctype->decimal : -1; +} +int _PyUnicode_IsDecimalDigit(Py_UCS4 ch) +{ +if (_PyUnicode_ToDecimalDigit(ch) < 0) +return 0; +return 1; +} +/* Returns the integer digit (0-9) for Unicode characters having +this property, -1 otherwise. */ +int _PyUnicode_ToDigit(Py_UCS4 ch) +{ +const _PyUnicode_TypeRecord *ctype = gettyperecord(ch); +return (ctype->flags & DIGIT_MASK) ? ctype->digit : -1; +} +int _PyUnicode_IsDigit(Py_UCS4 ch) +{ +if (_PyUnicode_ToDigit(ch) < 0) +return 0; +return 1; +} +/* Returns the numeric value as double for Unicode characters having +this property, -1.0 otherwise. */ +int _PyUnicode_IsNumeric(Py_UCS4 ch) +{ +const _PyUnicode_TypeRecord *ctype = gettyperecord(ch); +return (ctype->flags & NUMERIC_MASK) != 0; +} +/* Returns 1 for Unicode characters that repr() may use in its output, +and 0 for characters to be hex-escaped. +See documentation of `str.isprintable` for details. +*/ +int _PyUnicode_IsPrintable(Py_UCS4 ch) +{ +const _PyUnicode_TypeRecord *ctype = gettyperecord(ch); +return (ctype->flags & PRINTABLE_MASK) != 0; +} +/* Returns 1 for Unicode characters having the category 'Ll', 0 +otherwise. */ +int _PyUnicode_IsLowercase(Py_UCS4 ch) +{ +const _PyUnicode_TypeRecord *ctype = gettyperecord(ch); +return (ctype->flags & LOWER_MASK) != 0; +} +/* Returns 1 for Unicode characters having the category 'Lu', 0 +otherwise. */ +int _PyUnicode_IsUppercase(Py_UCS4 ch) +{ +const _PyUnicode_TypeRecord *ctype = gettyperecord(ch); +return (ctype->flags & UPPER_MASK) != 0; +} +/* Returns the uppercase Unicode characters corresponding to ch or just +ch if no uppercase mapping is known. */ +Py_UCS4 _PyUnicode_ToUppercase(Py_UCS4 ch) +{ +const _PyUnicode_TypeRecord *ctype = gettyperecord(ch); +if (ctype->flags & EXTENDED_CASE_MASK) +return _PyUnicode_ExtendedCase[ctype->upper & 0xFFFF]; +return ch + ctype->upper; +} +/* Returns the lowercase Unicode characters corresponding to ch or just +ch if no lowercase mapping is known. */ +Py_UCS4 _PyUnicode_ToLowercase(Py_UCS4 ch) +{ +const _PyUnicode_TypeRecord *ctype = gettyperecord(ch); +if (ctype->flags & EXTENDED_CASE_MASK) +return _PyUnicode_ExtendedCase[ctype->lower & 0xFFFF]; +return ch + ctype->lower; +} +int _PyUnicode_ToLowerFull(Py_UCS4 ch, Py_UCS4 *res) +{ +const _PyUnicode_TypeRecord *ctype = gettyperecord(ch); +if (ctype->flags & EXTENDED_CASE_MASK) { +int index = ctype->lower & 0xFFFF; +int n = ctype->lower >> 24; +int i; +for (i = 0; i < n; i++) +res[i] = _PyUnicode_ExtendedCase[index + i]; +return n; +} +res[0] = ch + ctype->lower; +return 1; +} +int _PyUnicode_ToTitleFull(Py_UCS4 ch, Py_UCS4 *res) +{ +const _PyUnicode_TypeRecord *ctype = gettyperecord(ch); +if (ctype->flags & EXTENDED_CASE_MASK) { +int index = ctype->title & 0xFFFF; +int n = ctype->title >> 24; +int i; +for (i = 0; i < n; i++) +res[i] = _PyUnicode_ExtendedCase[index + i]; +return n; +} +res[0] = ch + ctype->title; +return 1; +} +int _PyUnicode_ToUpperFull(Py_UCS4 ch, Py_UCS4 *res) +{ +const _PyUnicode_TypeRecord *ctype = gettyperecord(ch); +if (ctype->flags & EXTENDED_CASE_MASK) { +int index = ctype->upper & 0xFFFF; +int n = ctype->upper >> 24; +int i; +for (i = 0; i < n; i++) +res[i] = _PyUnicode_ExtendedCase[index + i]; +return n; +} +res[0] = ch + ctype->upper; +return 1; +} +int _PyUnicode_ToFoldedFull(Py_UCS4 ch, Py_UCS4 *res) +{ +const _PyUnicode_TypeRecord *ctype = gettyperecord(ch); +if (ctype->flags & EXTENDED_CASE_MASK && (ctype->lower >> 20) & 7) { +int index = (ctype->lower & 0xFFFF) + (ctype->lower >> 24); +int n = (ctype->lower >> 20) & 7; +int i; +for (i = 0; i < n; i++) +res[i] = _PyUnicode_ExtendedCase[index + i]; +return n; +} +return _PyUnicode_ToLowerFull(ch, res); +} +int _PyUnicode_IsCased(Py_UCS4 ch) +{ +const _PyUnicode_TypeRecord *ctype = gettyperecord(ch); +return (ctype->flags & CASED_MASK) != 0; +} +int _PyUnicode_IsCaseIgnorable(Py_UCS4 ch) +{ +const _PyUnicode_TypeRecord *ctype = gettyperecord(ch); +return (ctype->flags & CASE_IGNORABLE_MASK) != 0; +} +/* Returns 1 for Unicode characters having the category 'Ll', 'Lu', 'Lt', +'Lo' or 'Lm', 0 otherwise. */ +int _PyUnicode_IsAlpha(Py_UCS4 ch) +{ +const _PyUnicode_TypeRecord *ctype = gettyperecord(ch); +return (ctype->flags & ALPHA_MASK) != 0; +} + +#!/usr/bin/python +# Usage: typeslots.py < Include/typeslots.h typeslots.inc +import sys, re +def generate_typeslots(out=sys.stdout): +out.write("/* Generated by typeslots.py */\n") +res = {} +for line in sys.stdin: +m = re.match("#define Py_([a-z_]+) ([0-9]+)", line) +if not m: +continue +member = m.group(1) +if member == "tp_token": +# The heap type structure (ht_*) is an implementation detail; +# the public slot for it has a familiar `tp_` prefix +member = '{-1, offsetof(PyHeapTypeObject, ht_token)}' +elif member.startswith("tp_"): +member = f'{{-1, offsetof(PyTypeObject, {member})}}' +elif member.startswith("am_"): +member = (f'{{offsetof(PyAsyncMethods, {member}),'+ +' offsetof(PyTypeObject, tp_as_async)}') +elif member.startswith("nb_"): +member = (f'{{offsetof(PyNumberMethods, {member}),'+ +' offsetof(PyTypeObject, tp_as_number)}') +elif member.startswith("mp_"): +member = (f'{{offsetof(PyMappingMethods, {member}),'+ +' offsetof(PyTypeObject, tp_as_mapping)}') +elif member.startswith("sq_"): +member = (f'{{offsetof(PySequenceMethods, {member}),'+ +' offsetof(PyTypeObject, tp_as_sequence)}') +elif member.startswith("bf_"): +member = (f'{{offsetof(PyBufferProcs, {member}),'+ +' offsetof(PyTypeObject, tp_as_buffer)}') +res[int(m.group(2))] = member +M = max(res.keys())+1 +for i in range(1,M): +if i in res: +out.write("%s,\n" % res[i]) +else: +out.write("{0, 0},\n") +def main(): +if len(sys.argv) == 2: +with open(sys.argv[1], "w") as f: +generate_typeslots(f) +else: +generate_typeslots() +if __name__ == "__main__": +main() + +/* Wrap void * pointers to be passed between C modules */ +#include "Python.h" +#include "pycore_capsule.h" // export _PyCapsule_SetTraverse() +#include "pycore_gc.h" // _PyObject_GC_IS_TRACKED() +#include "pycore_object.h" // _PyObject_GC_TRACK() +/* Internal structure of PyCapsule */ +typedef struct { +PyObject_HEAD +void *pointer; +const char *name; +void *context; +PyCapsule_Destructor destructor; +traverseproc traverse_func; +inquiry clear_func; +} PyCapsule; +#define _PyCapsule_CAST(op) ((PyCapsule *)(op)) +static int +_is_legal_capsule(PyObject *op, const char *invalid_capsule) +{ +if (!op || !PyCapsule_CheckExact(op)) { +goto error; +} +PyCapsule *capsule = (PyCapsule *)op; +if (capsule->pointer == NULL) { +goto error; +} +return 1; +error: +PyErr_SetString(PyExc_ValueError, invalid_capsule); +return 0; +} +#define is_legal_capsule(capsule, name) \ +(_is_legal_capsule(capsule, \ +name " called with invalid PyCapsule object")) +static int +name_matches(const char *name1, const char *name2) { +/* if either is NULL, */ +if (!name1 || !name2) { +/* they're only the same if they're both NULL. */ +return name1 == name2; +} +return !strcmp(name1, name2); +} +PyObject * +PyCapsule_New(void *pointer, const char *name, PyCapsule_Destructor destructor) +{ +PyCapsule *capsule; +if (!pointer) { +PyErr_SetString(PyExc_ValueError, "PyCapsule_New called with null pointer"); +return NULL; +} +capsule = PyObject_GC_New(PyCapsule, &PyCapsule_Type); +if (capsule == NULL) { +return NULL; +} +capsule->pointer = pointer; +capsule->name = name; +capsule->context = NULL; +capsule->destructor = destructor; +capsule->traverse_func = NULL; +capsule->clear_func = NULL; +// Only track the object by the GC when _PyCapsule_SetTraverse() is called +return (PyObject *)capsule; +} +int +PyCapsule_IsValid(PyObject *op, const char *name) +{ +PyCapsule *capsule = (PyCapsule *)op; +return (capsule != NULL && +PyCapsule_CheckExact(capsule) && +capsule->pointer != NULL && +name_matches(capsule->name, name)); +} +void * +PyCapsule_GetPointer(PyObject *op, const char *name) +{ +if (!is_legal_capsule(op, "PyCapsule_GetPointer")) { +return NULL; +} +PyCapsule *capsule = (PyCapsule *)op; +if (!name_matches(name, capsule->name)) { +PyErr_SetString(PyExc_ValueError, "PyCapsule_GetPointer called with incorrect name"); +return NULL; +} +return capsule->pointer; +} +const char * +PyCapsule_GetName(PyObject *op) +{ +if (!is_legal_capsule(op, "PyCapsule_GetName")) { +return NULL; +} +PyCapsule *capsule = (PyCapsule *)op; +return capsule->name; +} +PyCapsule_Destructor +PyCapsule_GetDestructor(PyObject *op) +{ +if (!is_legal_capsule(op, "PyCapsule_GetDestructor")) { +return NULL; +} +PyCapsule *capsule = (PyCapsule *)op; +return capsule->destructor; +} +void * +PyCapsule_GetContext(PyObject *op) +{ +if (!is_legal_capsule(op, "PyCapsule_GetContext")) { +return NULL; +} +PyCapsule *capsule = (PyCapsule *)op; +return capsule->context; +} +int +PyCapsule_SetPointer(PyObject *op, void *pointer) +{ +if (!is_legal_capsule(op, "PyCapsule_SetPointer")) { +return -1; +} +PyCapsule *capsule = (PyCapsule *)op; +if (!pointer) { +PyErr_SetString(PyExc_ValueError, "PyCapsule_SetPointer called with null pointer"); +return -1; +} +capsule->pointer = pointer; +return 0; +} +int +PyCapsule_SetName(PyObject *op, const char *name) +{ +if (!is_legal_capsule(op, "PyCapsule_SetName")) { +return -1; +} +PyCapsule *capsule = (PyCapsule *)op; +capsule->name = name; +return 0; +} +int +PyCapsule_SetDestructor(PyObject *op, PyCapsule_Destructor destructor) +{ +if (!is_legal_capsule(op, "PyCapsule_SetDestructor")) { +return -1; +} +PyCapsule *capsule = (PyCapsule *)op; +capsule->destructor = destructor; +return 0; +} +int +PyCapsule_SetContext(PyObject *op, void *context) +{ +if (!is_legal_capsule(op, "PyCapsule_SetContext")) { +return -1; +} +PyCapsule *capsule = (PyCapsule *)op; +capsule->context = context; +return 0; +} +int +_PyCapsule_SetTraverse(PyObject *op, traverseproc traverse_func, inquiry clear_func) +{ +if (!is_legal_capsule(op, "_PyCapsule_SetTraverse")) { +return -1; +} +PyCapsule *capsule = (PyCapsule *)op; +if (traverse_func == NULL || clear_func == NULL) { +PyErr_SetString(PyExc_ValueError, +"_PyCapsule_SetTraverse() called with NULL callback"); +return -1; +} +if (!_PyObject_GC_IS_TRACKED(op)) { +_PyObject_GC_TRACK(op); +} +capsule->traverse_func = traverse_func; +capsule->clear_func = clear_func; +return 0; +} +void * +PyCapsule_Import(const char *name, int no_block) +{ +PyObject *object = NULL; +void *return_value = NULL; +char *trace; +size_t name_length = (strlen(name) + 1) * sizeof(char); +char *name_dup = (char *)PyMem_Malloc(name_length); +if (!name_dup) { +return PyErr_NoMemory(); +} +memcpy(name_dup, name, name_length); +trace = name_dup; +while (trace) { +char *dot = strchr(trace, '.'); +if (dot) { +*dot++ = '\0'; +} +if (object == NULL) { +object = PyImport_ImportModule(trace); +if (!object) { +PyErr_Format(PyExc_ImportError, "PyCapsule_Import could not import module \"%s\"", trace); +} +} else { +PyObject *object2 = PyObject_GetAttrString(object, trace); +Py_SETREF(object, object2); +} +if (!object) { +goto EXIT; +} +trace = dot; +} +/* compare attribute name to module.name by hand */ +if (PyCapsule_IsValid(object, name)) { +PyCapsule *capsule = (PyCapsule *)object; +return_value = capsule->pointer; +} else { +PyErr_Format(PyExc_AttributeError, +"PyCapsule_Import \"%s\" is not valid", +name); +} +EXIT: +Py_XDECREF(object); +if (name_dup) { +PyMem_Free(name_dup); +} +return return_value; +} +static void +capsule_dealloc(PyObject *op) +{ +PyCapsule *capsule = _PyCapsule_CAST(op); +PyObject_GC_UnTrack(op); +if (capsule->destructor) { +capsule->destructor(op); +} +PyObject_GC_Del(op); +} +static PyObject * +capsule_repr(PyObject *o) +{ +PyCapsule *capsule = _PyCapsule_CAST(o); +const char *name; +const char *quote; +if (capsule->name) { +quote = "\""; +name = capsule->name; +} else { +quote = ""; +name = "NULL"; +} +return PyUnicode_FromFormat("", +quote, name, quote, capsule); +} +static int +capsule_traverse(PyObject *self, visitproc visit, void *arg) +{ +// Capsule object is only tracked by the GC +// if _PyCapsule_SetTraverse() is called, but +// this can still be manually triggered by gc.get_referents() +PyCapsule *capsule = _PyCapsule_CAST(self); +if (capsule->traverse_func != NULL) { +return capsule->traverse_func(self, visit, arg); +} +return 0; +} +static int +capsule_clear(PyObject *self) +{ +// Capsule object is only tracked by the GC +// if _PyCapsule_SetTraverse() is called +PyCapsule *capsule = _PyCapsule_CAST(self); +assert(capsule->clear_func != NULL); +return capsule->clear_func(self); +} +PyDoc_STRVAR(PyCapsule_Type__doc__, +"Capsule objects let you wrap a C \"void *\" pointer in a Python\n\ +object. They're a way of passing data through the Python interpreter\n\ +without creating your own custom type.\n\ +\n\ +Capsules are used for communication between extension modules.\n\ +They provide a way for an extension module to export a C interface\n\ +to other extension modules, so that extension modules can use the\n\ +Python import mechanism to link to one another.\n\ +"); +PyTypeObject PyCapsule_Type = { +PyVarObject_HEAD_INIT(&PyType_Type, 0) +.tp_name = "PyCapsule", +.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, +.tp_basicsize = sizeof(PyCapsule), +.tp_dealloc = capsule_dealloc, +.tp_repr = capsule_repr, +.tp_doc = PyCapsule_Type__doc__, +.tp_traverse = capsule_traverse, +.tp_clear = capsule_clear, +}; + +// typing.Union -- used to represent e.g. Union[int, str], int | str +#include "Python.h" +#include "pycore_object.h" // _PyObject_GC_TRACK/UNTRACK +#include "pycore_typevarobject.h" // _PyTypeAlias_Type, _Py_typing_type_repr +#include "pycore_unicodeobject.h" // _PyUnicode_EqualToASCIIString +#include "pycore_unionobject.h" +#include "pycore_weakref.h" // FT_CLEAR_WEAKREFS() +typedef struct { +PyObject_HEAD +PyObject *args; // all args (tuple) +PyObject *hashable_args; // frozenset or NULL +PyObject *unhashable_args; // tuple or NULL +PyObject *parameters; +PyObject *weakreflist; +} unionobject; +static void +unionobject_dealloc(PyObject *self) +{ +unionobject *alias = (unionobject *)self; +_PyObject_GC_UNTRACK(self); +FT_CLEAR_WEAKREFS(self, alias->weakreflist); +Py_XDECREF(alias->args); +Py_XDECREF(alias->hashable_args); +Py_XDECREF(alias->unhashable_args); +Py_XDECREF(alias->parameters); +Py_TYPE(self)->tp_free(self); +} +static int +union_traverse(PyObject *self, visitproc visit, void *arg) +{ +unionobject *alias = (unionobject *)self; +Py_VISIT(alias->args); +Py_VISIT(alias->hashable_args); +Py_VISIT(alias->unhashable_args); +Py_VISIT(alias->parameters); +return 0; +} +static Py_hash_t +union_hash(PyObject *self) +{ +unionobject *alias = (unionobject *)self; +// If there are any unhashable args, treat this union as unhashable. +// Otherwise, two unions might compare equal but have different hashes. +if (alias->unhashable_args) { +// Attempt to get an error from one of the values. +assert(PyTuple_CheckExact(alias->unhashable_args)); +Py_ssize_t n = PyTuple_GET_SIZE(alias->unhashable_args); +for (Py_ssize_t i = 0; i < n; i++) { +PyObject *arg = PyTuple_GET_ITEM(alias->unhashable_args, i); +Py_hash_t hash = PyObject_Hash(arg); +if (hash == -1) { +return -1; +} +} +// The unhashable values somehow became hashable again. Still raise +// an error. +PyErr_Format(PyExc_TypeError, "union contains %d unhashable elements", n); +return -1; +} +return PyObject_Hash(alias->hashable_args); +} +static int +unions_equal(unionobject *a, unionobject *b) +{ +int result = PyObject_RichCompareBool(a->hashable_args, b->hashable_args, Py_EQ); +if (result == -1) { +return -1; +} +if (result == 0) { +return 0; +} +if (a->unhashable_args && b->unhashable_args) { +Py_ssize_t n = PyTuple_GET_SIZE(a->unhashable_args); +if (n != PyTuple_GET_SIZE(b->unhashable_args)) { +return 0; +} +for (Py_ssize_t i = 0; i < n; i++) { +PyObject *arg_a = PyTuple_GET_ITEM(a->unhashable_args, i); +int result = PySequence_Contains(b->unhashable_args, arg_a); +if (result == -1) { +return -1; +} +if (!result) { +return 0; +} +} +for (Py_ssize_t i = 0; i < n; i++) { +PyObject *arg_b = PyTuple_GET_ITEM(b->unhashable_args, i); +int result = PySequence_Contains(a->unhashable_args, arg_b); +if (result == -1) { +return -1; +} +if (!result) { +return 0; +} +} +} +else if (a->unhashable_args || b->unhashable_args) { +return 0; +} +return 1; +} +static PyObject * +union_richcompare(PyObject *a, PyObject *b, int op) +{ +if (!_PyUnion_Check(b) || (op != Py_EQ && op != Py_NE)) { +Py_RETURN_NOTIMPLEMENTED; +} +int equal = unions_equal((unionobject*)a, (unionobject*)b); +if (equal == -1) { +return NULL; +} +if (op == Py_EQ) { +return PyBool_FromLong(equal); +} +else { +return PyBool_FromLong(!equal); +} +} +typedef struct { +PyObject *args; // list +PyObject *hashable_args; // set +PyObject *unhashable_args; // list or NULL +bool is_checked; // whether to call type_check() +} unionbuilder; +static bool unionbuilder_add_tuple(unionbuilder *, PyObject *); +static PyObject *make_union(unionbuilder *); +static PyObject *type_check(PyObject *, const char *); +static bool +unionbuilder_init(unionbuilder *ub, bool is_checked) +{ +ub->args = PyList_New(0); +if (ub->args == NULL) { +return false; +} +ub->hashable_args = PySet_New(NULL); +if (ub->hashable_args == NULL) { +Py_DECREF(ub->args); +return false; +} +ub->unhashable_args = NULL; +ub->is_checked = is_checked; +return true; +} +static void +unionbuilder_finalize(unionbuilder *ub) +{ +Py_DECREF(ub->args); +Py_DECREF(ub->hashable_args); +Py_XDECREF(ub->unhashable_args); +} +static bool +unionbuilder_add_single_unchecked(unionbuilder *ub, PyObject *arg) +{ +Py_hash_t hash = PyObject_Hash(arg); +if (hash == -1) { +PyErr_Clear(); +if (ub->unhashable_args == NULL) { +ub->unhashable_args = PyList_New(0); +if (ub->unhashable_args == NULL) { +return false; +} +} +else { +int contains = PySequence_Contains(ub->unhashable_args, arg); +if (contains < 0) { +return false; +} +if (contains == 1) { +return true; +} +} +if (PyList_Append(ub->unhashable_args, arg) < 0) { +return false; +} +} +else { +int contains = PySet_Contains(ub->hashable_args, arg); +if (contains < 0) { +return false; +} +if (contains == 1) { +return true; +} +if (PySet_Add(ub->hashable_args, arg) < 0) { +return false; +} +} +return PyList_Append(ub->args, arg) == 0; +} +static bool +unionbuilder_add_single(unionbuilder *ub, PyObject *arg) +{ +if (Py_IsNone(arg)) { +arg = (PyObject *)&_PyNone_Type; // immortal, so no refcounting needed +} +else if (_PyUnion_Check(arg)) { +PyObject *args = ((unionobject *)arg)->args; +return unionbuilder_add_tuple(ub, args); +} +if (ub->is_checked) { +PyObject *type = type_check(arg, "Union[arg, ...]: each arg must be a type."); +if (type == NULL) { +return false; +} +bool result = unionbuilder_add_single_unchecked(ub, type); +Py_DECREF(type); +return result; +} +else { +return unionbuilder_add_single_unchecked(ub, arg); +} +} +static bool +unionbuilder_add_tuple(unionbuilder *ub, PyObject *tuple) +{ +Py_ssize_t n = PyTuple_GET_SIZE(tuple); +for (Py_ssize_t i = 0; i < n; i++) { +if (!unionbuilder_add_single(ub, PyTuple_GET_ITEM(tuple, i))) { +return false; +} +} +return true; +} +static int +is_unionable(PyObject *obj) +{ +if (obj == Py_None || +PyType_Check(obj) || +_PyGenericAlias_Check(obj) || +_PyUnion_Check(obj) || +Py_IS_TYPE(obj, &_PyTypeAlias_Type)) { +return 1; +} +return 0; +} +PyObject * +_Py_union_type_or(PyObject* self, PyObject* other) +{ +if (!is_unionable(self) || !is_unionable(other)) { +Py_RETURN_NOTIMPLEMENTED; +} +unionbuilder ub; +// unchecked because we already checked is_unionable() +if (!unionbuilder_init(&ub, false)) { +return NULL; +} +if (!unionbuilder_add_single(&ub, self) || +!unionbuilder_add_single(&ub, other)) { +unionbuilder_finalize(&ub); +return NULL; +} +PyObject *new_union = make_union(&ub); +return new_union; +} +static PyObject * +union_repr(PyObject *self) +{ +unionobject *alias = (unionobject *)self; +Py_ssize_t len = PyTuple_GET_SIZE(alias->args); +// Shortest type name "int" (3 chars) + " | " (3 chars) separator +Py_ssize_t estimate = (len <= PY_SSIZE_T_MAX / 6) ? len * 6 : len; +PyUnicodeWriter *writer = PyUnicodeWriter_Create(estimate); +if (writer == NULL) { +return NULL; +} +for (Py_ssize_t i = 0; i < len; i++) { +if (i > 0 && PyUnicodeWriter_WriteASCII(writer, " | ", 3) < 0) { +goto error; +} +PyObject *p = PyTuple_GET_ITEM(alias->args, i); +if (_Py_typing_type_repr(writer, p) < 0) { +goto error; +} +} +#if 0 +PyUnicodeWriter_WriteASCII(writer, "|args=", 6); +PyUnicodeWriter_WriteRepr(writer, alias->args); +PyUnicodeWriter_WriteASCII(writer, "|h=", 3); +PyUnicodeWriter_WriteRepr(writer, alias->hashable_args); +if (alias->unhashable_args) { +PyUnicodeWriter_WriteASCII(writer, "|u=", 3); +PyUnicodeWriter_WriteRepr(writer, alias->unhashable_args); +} +#endif +return PyUnicodeWriter_Finish(writer); +error: +PyUnicodeWriter_Discard(writer); +return NULL; +} +static PyMemberDef union_members[] = { +{"__args__", _Py_T_OBJECT, offsetof(unionobject, args), Py_READONLY}, +{0} +}; +// Populate __parameters__ if needed. +static int +union_init_parameters(unionobject *alias) +{ +int result = 0; +Py_BEGIN_CRITICAL_SECTION(alias); +if (alias->parameters == NULL) { +alias->parameters = _Py_make_parameters(alias->args); +if (alias->parameters == NULL) { +result = -1; +} +} +Py_END_CRITICAL_SECTION(); +return result; +} +static PyObject * +union_getitem(PyObject *self, PyObject *item) +{ +unionobject *alias = (unionobject *)self; +if (union_init_parameters(alias) < 0) { +return NULL; +} +PyObject *newargs = _Py_subs_parameters(self, alias->args, alias->parameters, item); +if (newargs == NULL) { +return NULL; +} +PyObject *res = _Py_union_from_tuple(newargs); +Py_DECREF(newargs); +return res; +} +static PyMappingMethods union_as_mapping = { +.mp_subscript = union_getitem, +}; +static PyObject * +union_parameters(PyObject *self, void *Py_UNUSED(unused)) +{ +unionobject *alias = (unionobject *)self; +if (union_init_parameters(alias) < 0) { +return NULL; +} +return Py_NewRef(alias->parameters); +} +static PyObject * +union_name(PyObject *Py_UNUSED(self), void *Py_UNUSED(ignored)) +{ +return PyUnicode_FromString("Union"); +} +static PyObject * +union_origin(PyObject *Py_UNUSED(self), void *Py_UNUSED(ignored)) +{ +return Py_NewRef(&_PyUnion_Type); +} +static PyGetSetDef union_properties[] = { +{"__name__", union_name, NULL, +PyDoc_STR("Name of the type"), NULL}, +{"__qualname__", union_name, NULL, +PyDoc_STR("Qualified name of the type"), NULL}, +{"__origin__", union_origin, NULL, +PyDoc_STR("Always returns the type"), NULL}, +{"__parameters__", union_parameters, NULL, +PyDoc_STR("Type variables in the types.UnionType."), NULL}, +{0} +}; +static PyObject * +union_nb_or(PyObject *a, PyObject *b) +{ +unionbuilder ub; +if (!unionbuilder_init(&ub, true)) { +return NULL; +} +if (!unionbuilder_add_single(&ub, a) || +!unionbuilder_add_single(&ub, b)) { +unionbuilder_finalize(&ub); +return NULL; +} +return make_union(&ub); +} +static PyNumberMethods union_as_number = { +.nb_or = union_nb_or, // Add __or__ function +}; +static const char* const cls_attrs[] = { +"__module__", // Required for compatibility with typing module +NULL, +}; +static PyObject * +union_getattro(PyObject *self, PyObject *name) +{ +unionobject *alias = (unionobject *)self; +if (PyUnicode_Check(name)) { +for (const char * const *p = cls_attrs; ; p++) { +if (*p == NULL) { +break; +} +if (_PyUnicode_EqualToASCIIString(name, *p)) { +return PyObject_GetAttr((PyObject *) Py_TYPE(alias), name); +} +} +} +return PyObject_GenericGetAttr(self, name); +} +PyObject * +_Py_union_args(PyObject *self) +{ +assert(_PyUnion_Check(self)); +return ((unionobject *) self)->args; +} +static PyObject * +call_typing_func_object(const char *name, PyObject **args, size_t nargs) +{ +PyObject *typing = PyImport_ImportModule("typing"); +if (typing == NULL) { +return NULL; +} +PyObject *func = PyObject_GetAttrString(typing, name); +if (func == NULL) { +Py_DECREF(typing); +return NULL; +} +PyObject *result = PyObject_Vectorcall(func, args, nargs, NULL); +Py_DECREF(func); +Py_DECREF(typing); +return result; +} +static PyObject * +type_check(PyObject *arg, const char *msg) +{ +if (Py_IsNone(arg)) { +// NoneType is immortal, so don't need an INCREF +return (PyObject *)Py_TYPE(arg); +} +// Fast path to avoid calling into typing.py +if (is_unionable(arg)) { +return Py_NewRef(arg); +} +PyObject *message_str = PyUnicode_FromString(msg); +if (message_str == NULL) { +return NULL; +} +PyObject *args[2] = {arg, message_str}; +PyObject *result = call_typing_func_object("_type_check", args, 2); +Py_DECREF(message_str); +return result; +} +PyObject * +_Py_union_from_tuple(PyObject *args) +{ +unionbuilder ub; +if (!unionbuilder_init(&ub, true)) { +return NULL; +} +if (PyTuple_CheckExact(args)) { +if (!unionbuilder_add_tuple(&ub, args)) { +unionbuilder_finalize(&ub); +return NULL; +} +} +else { +if (!unionbuilder_add_single(&ub, args)) { +unionbuilder_finalize(&ub); +return NULL; +} +} +return make_union(&ub); +} +static PyObject * +union_class_getitem(PyObject *cls, PyObject *args) +{ +return _Py_union_from_tuple(args); +} +static PyObject * +union_mro_entries(PyObject *self, PyObject *args) +{ +return PyErr_Format(PyExc_TypeError, +"Cannot subclass %R", self); +} +static PyMethodDef union_methods[] = { +{"__mro_entries__", union_mro_entries, METH_O}, +{"__class_getitem__", union_class_getitem, METH_O|METH_CLASS, PyDoc_STR("See PEP 585")}, +{0} +}; +PyTypeObject _PyUnion_Type = { +PyVarObject_HEAD_INIT(&PyType_Type, 0) +.tp_name = "typing.Union", +.tp_doc = PyDoc_STR("Represent a union type\n" +"\n" +"E.g. for int | str"), +.tp_basicsize = sizeof(unionobject), +.tp_dealloc = unionobject_dealloc, +.tp_alloc = PyType_GenericAlloc, +.tp_free = PyObject_GC_Del, +.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, +.tp_traverse = union_traverse, +.tp_hash = union_hash, +.tp_getattro = union_getattro, +.tp_members = union_members, +.tp_methods = union_methods, +.tp_richcompare = union_richcompare, +.tp_as_mapping = &union_as_mapping, +.tp_as_number = &union_as_number, +.tp_repr = union_repr, +.tp_getset = union_properties, +.tp_weaklistoffset = offsetof(unionobject, weakreflist), +}; +static PyObject * +make_union(unionbuilder *ub) +{ +Py_ssize_t n = PyList_GET_SIZE(ub->args); +if (n == 0) { +PyErr_SetString(PyExc_TypeError, "Cannot take a Union of no types."); +unionbuilder_finalize(ub); +return NULL; +} +if (n == 1) { +PyObject *result = PyList_GET_ITEM(ub->args, 0); +Py_INCREF(result); +unionbuilder_finalize(ub); +return result; +} +PyObject *args = NULL, *hashable_args = NULL, *unhashable_args = NULL; +args = PyList_AsTuple(ub->args); +if (args == NULL) { +goto error; +} +hashable_args = PyFrozenSet_New(ub->hashable_args); +if (hashable_args == NULL) { +goto error; +} +if (ub->unhashable_args != NULL) { +unhashable_args = PyList_AsTuple(ub->unhashable_args); +if (unhashable_args == NULL) { +goto error; +} +} +unionobject *result = PyObject_GC_New(unionobject, &_PyUnion_Type); +if (result == NULL) { +goto error; +} +unionbuilder_finalize(ub); +result->parameters = NULL; +result->args = args; +result->hashable_args = hashable_args; +result->unhashable_args = unhashable_args; +result->weakreflist = NULL; +_PyObject_GC_TRACK(result); +return (PyObject*)result; +error: +Py_XDECREF(args); +Py_XDECREF(hashable_args); +Py_XDECREF(unhashable_args); +unionbuilder_finalize(ub); +return NULL; +} + +/* t-string Interpolation object implementation */ +#include "Python.h" +#include "pycore_initconfig.h" // _PyStatus_OK +#include "pycore_interpolation.h" +#include "pycore_typeobject.h" // _PyType_GetDict +static int +_conversion_converter(PyObject *arg, PyObject **conversion) +{ +if (arg == Py_None) { +return 1; +} +if (!PyUnicode_Check(arg)) { +PyErr_Format(PyExc_TypeError, +"Interpolation() argument 'conversion' must be str, not %T", +arg); +return 0; +} +Py_ssize_t len; +const char *conv_str = PyUnicode_AsUTF8AndSize(arg, &len); +if (len != 1 || !(conv_str[0] == 'a' || conv_str[0] == 'r' || conv_str[0] == 's')) { +PyErr_SetString(PyExc_ValueError, +"Interpolation() argument 'conversion' must be one of 's', 'a' or 'r'"); +return 0; +} +*conversion = arg; +return 1; +} +#include "clinic/interpolationobject.c.h" +/*[clinic input] +class Interpolation "interpolationobject *" "&_PyInterpolation_Type" +[clinic start generated code]*/ +/*[clinic end generated code: output=da39a3ee5e6b4b0d input=161c64a16f9c4544]*/ +typedef struct { +PyObject_HEAD +PyObject *value; +PyObject *expression; +PyObject *conversion; +PyObject *format_spec; +} interpolationobject; +#define interpolationobject_CAST(op) \ +(assert(_PyInterpolation_CheckExact(op)), _Py_CAST(interpolationobject*, (op))) +/*[clinic input] +@classmethod +Interpolation.__new__ as interpolation_new +value: object +expression: object(subclass_of='&PyUnicode_Type', c_default='&_Py_STR(empty)') = "" +conversion: object(converter='_conversion_converter') = None +format_spec: object(subclass_of='&PyUnicode_Type', c_default='&_Py_STR(empty)') = "" +[clinic start generated code]*/ +static PyObject * +interpolation_new_impl(PyTypeObject *type, PyObject *value, +PyObject *expression, PyObject *conversion, +PyObject *format_spec) +/*[clinic end generated code: output=6488e288765bc1a9 input=fc5c285c1dd23d36]*/ +{ +interpolationobject *self = PyObject_GC_New(interpolationobject, type); +if (!self) { +return NULL; +} +self->value = Py_NewRef(value); +self->expression = Py_NewRef(expression); +self->conversion = Py_NewRef(conversion); +self->format_spec = Py_NewRef(format_spec); +PyObject_GC_Track(self); +return (PyObject *) self; +} +static void +interpolation_dealloc(PyObject *op) +{ +PyObject_GC_UnTrack(op); +Py_TYPE(op)->tp_clear(op); +Py_TYPE(op)->tp_free(op); +} +static int +interpolation_clear(PyObject *op) +{ +interpolationobject *self = interpolationobject_CAST(op); +Py_CLEAR(self->value); +Py_CLEAR(self->expression); +Py_CLEAR(self->conversion); +Py_CLEAR(self->format_spec); +return 0; +} +static int +interpolation_traverse(PyObject *op, visitproc visit, void *arg) +{ +interpolationobject *self = interpolationobject_CAST(op); +Py_VISIT(self->value); +Py_VISIT(self->expression); +Py_VISIT(self->conversion); +Py_VISIT(self->format_spec); +return 0; +} +static PyObject * +interpolation_repr(PyObject *op) +{ +interpolationobject *self = interpolationobject_CAST(op); +return PyUnicode_FromFormat("%s(%R, %R, %R, %R)", +_PyType_Name(Py_TYPE(self)), self->value, self->expression, +self->conversion, self->format_spec); +} +static PyMemberDef interpolation_members[] = { +{"value", Py_T_OBJECT_EX, offsetof(interpolationobject, value), Py_READONLY, "Value"}, +{"expression", Py_T_OBJECT_EX, offsetof(interpolationobject, expression), Py_READONLY, "Expression"}, +{"conversion", Py_T_OBJECT_EX, offsetof(interpolationobject, conversion), Py_READONLY, "Conversion"}, +{"format_spec", Py_T_OBJECT_EX, offsetof(interpolationobject, format_spec), Py_READONLY, "Format specifier"}, +{NULL} +}; +static PyObject* +interpolation_reduce(PyObject *op, PyObject *Py_UNUSED(dummy)) +{ +interpolationobject *self = interpolationobject_CAST(op); +return Py_BuildValue("(O(OOOO))", (PyObject *)Py_TYPE(op), +self->value, self->expression, +self->conversion, self->format_spec); +} +static PyMethodDef interpolation_methods[] = { +{"__reduce__", interpolation_reduce, METH_NOARGS, +PyDoc_STR("__reduce__() -> (cls, state)")}, +{"__class_getitem__", Py_GenericAlias, +METH_O|METH_CLASS, PyDoc_STR("See PEP 585")}, +{NULL, NULL}, +}; +PyTypeObject _PyInterpolation_Type = { +PyVarObject_HEAD_INIT(NULL, 0) +.tp_name = "string.templatelib.Interpolation", +.tp_doc = PyDoc_STR("Interpolation object"), +.tp_basicsize = sizeof(interpolationobject), +.tp_itemsize = 0, +.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, +.tp_new = interpolation_new, +.tp_alloc = PyType_GenericAlloc, +.tp_dealloc = interpolation_dealloc, +.tp_clear = interpolation_clear, +.tp_free = PyObject_GC_Del, +.tp_repr = interpolation_repr, +.tp_members = interpolation_members, +.tp_methods = interpolation_methods, +.tp_traverse = interpolation_traverse, +}; +PyStatus +_PyInterpolation_InitTypes(PyInterpreterState *interp) +{ +PyObject *tuple = Py_BuildValue("(ssss)", "value", "expression", "conversion", "format_spec"); +if (!tuple) { +goto error; +} +PyObject *dict = _PyType_GetDict(&_PyInterpolation_Type); +if (!dict) { +Py_DECREF(tuple); +goto error; +} +int status = PyDict_SetItemString(dict, "__match_args__", tuple); +Py_DECREF(tuple); +if (status < 0) { +goto error; +} +return _PyStatus_OK(); +error: +return _PyStatus_ERR("Can't initialize interpolation types"); +} +PyObject * +_PyInterpolation_Build(PyObject *value, PyObject *str, int conversion, PyObject *format_spec) +{ +interpolationobject *interpolation = PyObject_GC_New(interpolationobject, &_PyInterpolation_Type); +if (!interpolation) { +return NULL; +} +interpolation->value = Py_NewRef(value); +interpolation->expression = Py_NewRef(str); +interpolation->format_spec = Py_NewRef(format_spec); +interpolation->conversion = NULL; +if (conversion == 0) { +interpolation->conversion = Py_None; +} +else { +switch (conversion) { +case FVC_ASCII: +interpolation->conversion = _Py_LATIN1_CHR('a'); +break; +case FVC_REPR: +interpolation->conversion = _Py_LATIN1_CHR('r'); +break; +case FVC_STR: +interpolation->conversion = _Py_LATIN1_CHR('s'); +break; +default: +PyErr_SetString(PyExc_SystemError, +"Interpolation() argument 'conversion' must be one of 's', 'a' or 'r'"); +Py_DECREF(interpolation); +return NULL; +} +} +PyObject_GC_Track(interpolation); +return (PyObject *) interpolation; +} +PyObject * +_PyInterpolation_GetValueRef(PyObject *interpolation) +{ +return Py_NewRef(interpolationobject_CAST(interpolation)->value); +} + +#include "Python.h" +#include "pycore_abstract.h" // _PyIndex_Check() +#include "pycore_bytes_methods.h" +PyDoc_STRVAR_shared(_Py_isspace__doc__, +"B.isspace() -> bool\n\ +\n\ +Return True if all characters in B are whitespace\n\ +and there is at least one character in B, False otherwise."); +PyObject* +_Py_bytes_isspace(const char *cptr, Py_ssize_t len) +{ +const unsigned char *p += (const unsigned char *) cptr; +const unsigned char *e; +/* Shortcut for single character strings */ +if (len == 1 && Py_ISSPACE(*p)) +Py_RETURN_TRUE; +/* Special case for empty strings */ +if (len == 0) +Py_RETURN_FALSE; +e = p + len; +for (; p < e; p++) { +if (!Py_ISSPACE(*p)) +Py_RETURN_FALSE; +} +Py_RETURN_TRUE; +} +PyDoc_STRVAR_shared(_Py_isalpha__doc__, +"B.isalpha() -> bool\n\ +\n\ +Return True if all characters in B are alphabetic\n\ +and there is at least one character in B, False otherwise."); +PyObject* +_Py_bytes_isalpha(const char *cptr, Py_ssize_t len) +{ +const unsigned char *p += (const unsigned char *) cptr; +const unsigned char *e; +/* Shortcut for single character strings */ +if (len == 1 && Py_ISALPHA(*p)) +Py_RETURN_TRUE; +/* Special case for empty strings */ +if (len == 0) +Py_RETURN_FALSE; +e = p + len; +for (; p < e; p++) { +if (!Py_ISALPHA(*p)) +Py_RETURN_FALSE; +} +Py_RETURN_TRUE; +} +PyDoc_STRVAR_shared(_Py_isalnum__doc__, +"B.isalnum() -> bool\n\ +\n\ +Return True if all characters in B are alphanumeric\n\ +and there is at least one character in B, False otherwise."); +PyObject* +_Py_bytes_isalnum(const char *cptr, Py_ssize_t len) +{ +const unsigned char *p += (const unsigned char *) cptr; +const unsigned char *e; +/* Shortcut for single character strings */ +if (len == 1 && Py_ISALNUM(*p)) +Py_RETURN_TRUE; +/* Special case for empty strings */ +if (len == 0) +Py_RETURN_FALSE; +e = p + len; +for (; p < e; p++) { +if (!Py_ISALNUM(*p)) +Py_RETURN_FALSE; +} +Py_RETURN_TRUE; +} +PyDoc_STRVAR_shared(_Py_isdigit__doc__, +"B.isdigit() -> bool\n\ +\n\ +Return True if all characters in B are digits\n\ +and there is at least one character in B, False otherwise."); +PyObject* +_Py_bytes_isdigit(const char *cptr, Py_ssize_t len) +{ +const unsigned char *p += (const unsigned char *) cptr; +const unsigned char *e; +/* Shortcut for single character strings */ +if (len == 1 && Py_ISDIGIT(*p)) +Py_RETURN_TRUE; +/* Special case for empty strings */ +if (len == 0) +Py_RETURN_FALSE; +e = p + len; +for (; p < e; p++) { +if (!Py_ISDIGIT(*p)) +Py_RETURN_FALSE; +} +Py_RETURN_TRUE; +} +PyDoc_STRVAR_shared(_Py_islower__doc__, +"B.islower() -> bool\n\ +\n\ +Return True if all cased characters in B are lowercase and there is\n\ +at least one cased character in B, False otherwise."); +PyObject* +_Py_bytes_islower(const char *cptr, Py_ssize_t len) +{ +const unsigned char *p += (const unsigned char *) cptr; +const unsigned char *e; +int cased; +/* Shortcut for single character strings */ +if (len == 1) +return PyBool_FromLong(Py_ISLOWER(*p)); +/* Special case for empty strings */ +if (len == 0) +Py_RETURN_FALSE; +e = p + len; +cased = 0; +for (; p < e; p++) { +if (Py_ISUPPER(*p)) +Py_RETURN_FALSE; +else if (!cased && Py_ISLOWER(*p)) +cased = 1; +} +return PyBool_FromLong(cased); +} +PyDoc_STRVAR_shared(_Py_isupper__doc__, +"B.isupper() -> bool\n\ +\n\ +Return True if all cased characters in B are uppercase and there is\n\ +at least one cased character in B, False otherwise."); +PyObject* +_Py_bytes_isupper(const char *cptr, Py_ssize_t len) +{ +const unsigned char *p += (const unsigned char *) cptr; +const unsigned char *e; +int cased; +/* Shortcut for single character strings */ +if (len == 1) +return PyBool_FromLong(Py_ISUPPER(*p)); +/* Special case for empty strings */ +if (len == 0) +Py_RETURN_FALSE; +e = p + len; +cased = 0; +for (; p < e; p++) { +if (Py_ISLOWER(*p)) +Py_RETURN_FALSE; +else if (!cased && Py_ISUPPER(*p)) +cased = 1; +} +return PyBool_FromLong(cased); +} +PyDoc_STRVAR_shared(_Py_istitle__doc__, +"B.istitle() -> bool\n\ +\n\ +Return True if B is a titlecased string and there is at least one\n\ +character in B, i.e. uppercase characters may only follow uncased\n\ +characters and lowercase characters only cased ones. Return False\n\ +otherwise."); +PyObject* +_Py_bytes_istitle(const char *cptr, Py_ssize_t len) +{ +const unsigned char *p += (const unsigned char *) cptr; +const unsigned char *e; +int cased, previous_is_cased; +if (len == 1) { +if (Py_ISUPPER(*p)) { +Py_RETURN_TRUE; +} +Py_RETURN_FALSE; +} +/* Special case for empty strings */ +if (len == 0) +Py_RETURN_FALSE; +e = p + len; +cased = 0; +previous_is_cased = 0; +for (; p < e; p++) { +const unsigned char ch = *p; +if (Py_ISUPPER(ch)) { +if (previous_is_cased) +Py_RETURN_FALSE; +previous_is_cased = 1; +cased = 1; +} +else if (Py_ISLOWER(ch)) { +if (!previous_is_cased) +Py_RETURN_FALSE; +previous_is_cased = 1; +cased = 1; +} +else +previous_is_cased = 0; +} +return PyBool_FromLong(cased); +} +PyDoc_STRVAR_shared(_Py_lower__doc__, +"B.lower() -> copy of B\n\ +\n\ +Return a copy of B with all ASCII characters converted to lowercase."); +void +_Py_bytes_lower(char *result, const char *cptr, Py_ssize_t len) +{ +Py_ssize_t i; +for (i = 0; i < len; i++) { +result[i] = Py_TOLOWER((unsigned char) cptr[i]); +} +} +PyDoc_STRVAR_shared(_Py_upper__doc__, +"B.upper() -> copy of B\n\ +\n\ +Return a copy of B with all ASCII characters converted to uppercase."); +void +_Py_bytes_upper(char *result, const char *cptr, Py_ssize_t len) +{ +Py_ssize_t i; +for (i = 0; i < len; i++) { +result[i] = Py_TOUPPER((unsigned char) cptr[i]); +} +} +PyDoc_STRVAR_shared(_Py_title__doc__, +"B.title() -> copy of B\n\ +\n\ +Return a titlecased version of B, i.e. ASCII words start with uppercase\n\ +characters, all remaining cased characters have lowercase."); +void +_Py_bytes_title(char *result, const char *s, Py_ssize_t len) +{ +Py_ssize_t i; +int previous_is_cased = 0; +for (i = 0; i < len; i++) { +int c = Py_CHARMASK(*s++); +if (Py_ISLOWER(c)) { +if (!previous_is_cased) +c = Py_TOUPPER(c); +previous_is_cased = 1; +} else if (Py_ISUPPER(c)) { +if (previous_is_cased) +c = Py_TOLOWER(c); +previous_is_cased = 1; +} else +previous_is_cased = 0; +*result++ = c; +} +} +PyDoc_STRVAR_shared(_Py_capitalize__doc__, +"B.capitalize() -> copy of B\n\ +\n\ +Return a copy of B with only its first character capitalized (ASCII)\n\ +and the rest lower-cased."); +void +_Py_bytes_capitalize(char *result, const char *s, Py_ssize_t len) +{ +if (len > 0) { +*result = Py_TOUPPER(*s); +_Py_bytes_lower(result + 1, s + 1, len - 1); +} +} +PyDoc_STRVAR_shared(_Py_swapcase__doc__, +"B.swapcase() -> copy of B\n\ +\n\ +Return a copy of B with uppercase ASCII characters converted\n\ +to lowercase ASCII and vice versa."); +void +_Py_bytes_swapcase(char *result, const char *s, Py_ssize_t len) +{ +Py_ssize_t i; +for (i = 0; i < len; i++) { +int c = Py_CHARMASK(*s++); +if (Py_ISLOWER(c)) { +*result = Py_TOUPPER(c); +} +else if (Py_ISUPPER(c)) { +*result = Py_TOLOWER(c); +} +else +*result = c; +result++; +} +} +PyDoc_STRVAR_shared(_Py_maketrans__doc__, +"B.maketrans(frm, to) -> translation table\n\ +\n\ +Return a translation table (a bytes object of length 256) suitable\n\ +for use in the bytes or bytearray translate method where each byte\n\ +in frm is mapped to the byte at the same position in to.\n\ +The bytes objects frm and to must be of the same length."); +PyObject * +_Py_bytes_maketrans(Py_buffer *frm, Py_buffer *to) +{ +if (frm->len != to->len) { +PyErr_Format(PyExc_ValueError, +"maketrans arguments must have same length"); +return NULL; +} +PyBytesWriter *writer = PyBytesWriter_Create(256); +if (!writer) { +return NULL; +} +char *p = PyBytesWriter_GetData(writer); +Py_ssize_t i; +for (i = 0; i < 256; i++) +p[i] = (char) i; +for (i = 0; i < frm->len; i++) { +p[((unsigned char *)frm->buf)[i]] = ((char *)to->buf)[i]; +} +return PyBytesWriter_Finish(writer); +} +#define FASTSEARCH fastsearch +#define STRINGLIB(F) stringlib_##F +#define STRINGLIB_CHAR char +#define STRINGLIB_SIZEOF_CHAR 1 +#define STRINGLIB_FAST_MEMCHR memchr +#include "stringlib/fastsearch.h" +#include "stringlib/count.h" +#include "stringlib/find.h" +#include "stringlib/find_max_char.h" +/* +Wraps stringlib_parse_args_finds() and additionally checks the first +argument type. +In case the first argument is a bytes-like object, sets it to subobj, +and doesn't touch the byte parameter. +In case it is an integer in range(0, 256), writes the integer value +to byte, and sets subobj to NULL. +The other parameters are similar to those of +stringlib_parse_args_finds(). +*/ +Py_LOCAL_INLINE(int) +parse_args_finds_byte(const char *function_name, PyObject **subobj, char *byte) +{ +if (PyObject_CheckBuffer(*subobj)) { +return 1; +} +if (!_PyIndex_Check(*subobj)) { +PyErr_Format(PyExc_TypeError, +"argument should be integer or bytes-like object, " +"not '%.200s'", +Py_TYPE(*subobj)->tp_name); +return 0; +} +Py_ssize_t ival = PyNumber_AsSsize_t(*subobj, NULL); +if (ival == -1 && PyErr_Occurred()) { +return 0; +} +if (ival < 0 || ival > 255) { +PyErr_SetString(PyExc_ValueError, "byte must be in range(0, 256)"); +return 0; +} +*subobj = NULL; +*byte = (char)ival; +return 1; +} +/* helper macro to fixup start/end slice values */ +#define ADJUST_INDICES(start, end, len) \ +do { \ +if (end > len) { \ +end = len; \ +} \ +else if (end < 0) { \ +end += len; \ +if (end < 0) { \ +end = 0; \ +} \ +} \ +if (start < 0) { \ +start += len; \ +if (start < 0) { \ +start = 0; \ +} \ +} \ +} while (0) +Py_LOCAL_INLINE(Py_ssize_t) +find_internal(const char *str, Py_ssize_t len, +const char *function_name, PyObject *subobj, +Py_ssize_t start, Py_ssize_t end, +int dir) +{ +char byte; +Py_buffer subbuf; +const char *sub; +Py_ssize_t sub_len; +Py_ssize_t res; +if (!parse_args_finds_byte(function_name, &subobj, &byte)) { +return -2; +} +if (subobj) { +if (PyObject_GetBuffer(subobj, &subbuf, PyBUF_SIMPLE) != 0) +return -2; +sub = subbuf.buf; +sub_len = subbuf.len; +} +else { +sub = &byte; +sub_len = 1; +} +ADJUST_INDICES(start, end, len); +if (end - start < sub_len) +res = -1; +else if (sub_len == 1) { +if (dir > 0) +res = stringlib_find_char( +str + start, end - start, +*sub); +else +res = stringlib_rfind_char( +str + start, end - start, +*sub); +if (res >= 0) +res += start; +} +else { +if (dir > 0) +res = stringlib_find_slice( +str, len, +sub, sub_len, start, end); +else +res = stringlib_rfind_slice( +str, len, +sub, sub_len, start, end); +} +if (subobj) +PyBuffer_Release(&subbuf); +return res; +} +PyObject * +_Py_bytes_find(const char *str, Py_ssize_t len, PyObject *sub, +Py_ssize_t start, Py_ssize_t end) +{ +Py_ssize_t result = find_internal(str, len, "find", sub, start, end, +1); +if (result == -2) +return NULL; +return PyLong_FromSsize_t(result); +} +PyObject * +_Py_bytes_index(const char *str, Py_ssize_t len, PyObject *sub, +Py_ssize_t start, Py_ssize_t end) +{ +Py_ssize_t result = find_internal(str, len, "index", sub, start, end, +1); +if (result == -2) +return NULL; +if (result == -1) { +PyErr_SetString(PyExc_ValueError, +"subsection not found"); +return NULL; +} +return PyLong_FromSsize_t(result); +} +PyObject * +_Py_bytes_rfind(const char *str, Py_ssize_t len, PyObject *sub, +Py_ssize_t start, Py_ssize_t end) +{ +Py_ssize_t result = find_internal(str, len, "rfind", sub, start, end, -1); +if (result == -2) +return NULL; +return PyLong_FromSsize_t(result); +} +PyObject * +_Py_bytes_rindex(const char *str, Py_ssize_t len, PyObject *sub, +Py_ssize_t start, Py_ssize_t end) +{ +Py_ssize_t result = find_internal(str, len, "rindex", sub, start, end, -1); +if (result == -2) +return NULL; +if (result == -1) { +PyErr_SetString(PyExc_ValueError, +"subsection not found"); +return NULL; +} +return PyLong_FromSsize_t(result); +} +PyObject * +_Py_bytes_count(const char *str, Py_ssize_t len, PyObject *sub_obj, +Py_ssize_t start, Py_ssize_t end) +{ +const char *sub; +Py_ssize_t sub_len; +char byte; +Py_buffer vsub; +PyObject *count_obj; +if (!parse_args_finds_byte("count", &sub_obj, &byte)) { +return NULL; +} +if (sub_obj) { +if (PyObject_GetBuffer(sub_obj, &vsub, PyBUF_SIMPLE) != 0) +return NULL; +sub = vsub.buf; +sub_len = vsub.len; +} +else { +sub = &byte; +sub_len = 1; +} +ADJUST_INDICES(start, end, len); +count_obj = PyLong_FromSsize_t( +stringlib_count(str + start, end - start, sub, sub_len, PY_SSIZE_T_MAX) +); +if (sub_obj) +PyBuffer_Release(&vsub); +return count_obj; +} +int +_Py_bytes_contains(const char *str, Py_ssize_t len, PyObject *arg) +{ +Py_ssize_t ival = PyNumber_AsSsize_t(arg, NULL); +if (ival == -1 && PyErr_Occurred()) { +Py_buffer varg; +Py_ssize_t pos; +PyErr_Clear(); +if (PyObject_GetBuffer(arg, &varg, PyBUF_SIMPLE) != 0) +return -1; +pos = stringlib_find(str, len, +varg.buf, varg.len, 0); +PyBuffer_Release(&varg); +return pos >= 0; +} +if (ival < 0 || ival >= 256) { +PyErr_SetString(PyExc_ValueError, "byte must be in range(0, 256)"); +return -1; +} +return memchr(str, (int) ival, len) != NULL; +} +/* Matches the end (direction >= 0) or start (direction < 0) of the buffer +* against substr, using the start and end arguments. Returns +* -1 on error, 0 if not found and 1 if found. +*/ +static int +tailmatch(const char *str, Py_ssize_t len, PyObject *substr, +Py_ssize_t start, Py_ssize_t end, int direction) +{ +Py_buffer sub_view = {NULL, NULL}; +const char *sub; +Py_ssize_t slen; +if (PyBytes_Check(substr)) { +sub = PyBytes_AS_STRING(substr); +slen = PyBytes_GET_SIZE(substr); +} +else { +if (PyObject_GetBuffer(substr, &sub_view, PyBUF_SIMPLE) != 0) +return -1; +sub = sub_view.buf; +slen = sub_view.len; +} +ADJUST_INDICES(start, end, len); +if (direction < 0) { +/* startswith */ +if (start > len - slen) +goto notfound; +} else { +/* endswith */ +if (end - start < slen || start > len) +goto notfound; +if (end - slen > start) +start = end - slen; +} +if (end - start < slen) +goto notfound; +if (memcmp(str + start, sub, slen) != 0) +goto notfound; +PyBuffer_Release(&sub_view); +return 1; +notfound: +PyBuffer_Release(&sub_view); +return 0; +} +static PyObject * +_Py_bytes_tailmatch(const char *str, Py_ssize_t len, +const char *function_name, PyObject *subobj, +Py_ssize_t start, Py_ssize_t end, +int direction) +{ +if (PyTuple_Check(subobj)) { +Py_ssize_t i; +for (i = 0; i < PyTuple_GET_SIZE(subobj); i++) { +PyObject *item = PyTuple_GET_ITEM(subobj, i); +int result = tailmatch(str, len, item, start, end, direction); +if (result < 0) { +return NULL; +} +else if (result) { +Py_RETURN_TRUE; +} +} +Py_RETURN_FALSE; +} +int result = tailmatch(str, len, subobj, start, end, direction); +if (result == -1) { +if (PyErr_ExceptionMatches(PyExc_TypeError)) { +PyErr_Format(PyExc_TypeError, +"%s first arg must be bytes or a tuple of bytes, " +"not %s", +function_name, Py_TYPE(subobj)->tp_name); +} +return NULL; +} +return PyBool_FromLong(result); +} +PyObject * +_Py_bytes_startswith(const char *str, Py_ssize_t len, PyObject *subobj, +Py_ssize_t start, Py_ssize_t end) +{ +return _Py_bytes_tailmatch(str, len, "startswith", subobj, start, end, -1); +} +PyObject * +_Py_bytes_endswith(const char *str, Py_ssize_t len, PyObject *subobj, +Py_ssize_t start, Py_ssize_t end) +{ +return _Py_bytes_tailmatch(str, len, "endswith", subobj, start, end, +1); +} +PyDoc_STRVAR_shared(_Py_isascii__doc__, +"B.isascii() -> bool\n\ +\n\ +Return True if B is empty or all characters in B are ASCII,\n\ +False otherwise."); +PyObject* +_Py_bytes_isascii(const char *cptr, Py_ssize_t len) +{ +const char *p = cptr; +const char *end = p + len; +Py_ssize_t max_char = stringlib_find_max_char(cptr, end); +if (max_char > 127) { +Py_RETURN_FALSE; +} +Py_RETURN_TRUE; +} + + +"""