webview-python 0.99.16__cp312-cp312-win_amd64.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (10) hide show
  1. webview/__init__.py +0 -0
  2. webview/_dummy_holder.c +3972 -0
  3. webview/_dummy_holder.cp312-win_amd64.pyd +0 -0
  4. webview/_webview_ffi.py +134 -0
  5. webview/webview.py +92 -0
  6. webview_python-0.99.16.dist-info/LICENSE +21 -0
  7. webview_python-0.99.16.dist-info/METADATA +292 -0
  8. webview_python-0.99.16.dist-info/RECORD +10 -0
  9. webview_python-0.99.16.dist-info/WHEEL +5 -0
  10. webview_python-0.99.16.dist-info/top_level.txt +1 -0
webview/_dummy_holder.c ADDED
@@ -0,0 +1,3972 @@
1
+ /* Generated by Cython 3.0.11 */
2
+
3
+ /* BEGIN: Cython Metadata
4
+ {
5
+ "distutils": {
6
+ "name": "webview._dummy_holder",
7
+ "sources": [
8
+ "src/webview/_dummy_holder.pyx"
9
+ ]
10
+ },
11
+ "module_name": "webview._dummy_holder"
12
+ }
13
+ END: Cython Metadata */
14
+
15
+ #ifndef PY_SSIZE_T_CLEAN
16
+ #define PY_SSIZE_T_CLEAN
17
+ #endif /* PY_SSIZE_T_CLEAN */
18
+ #if defined(CYTHON_LIMITED_API) && 0
19
+ #ifndef Py_LIMITED_API
20
+ #if CYTHON_LIMITED_API+0 > 0x03030000
21
+ #define Py_LIMITED_API CYTHON_LIMITED_API
22
+ #else
23
+ #define Py_LIMITED_API 0x03030000
24
+ #endif
25
+ #endif
26
+ #endif
27
+
28
+ #include "Python.h"
29
+ #ifndef Py_PYTHON_H
30
+ #error Python headers needed to compile C extensions, please install development version of Python.
31
+ #elif PY_VERSION_HEX < 0x02070000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000)
32
+ #error Cython requires Python 2.7+ or Python 3.3+.
33
+ #else
34
+ #if defined(CYTHON_LIMITED_API) && CYTHON_LIMITED_API
35
+ #define __PYX_EXTRA_ABI_MODULE_NAME "limited"
36
+ #else
37
+ #define __PYX_EXTRA_ABI_MODULE_NAME ""
38
+ #endif
39
+ #define CYTHON_ABI "3_0_11" __PYX_EXTRA_ABI_MODULE_NAME
40
+ #define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI
41
+ #define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "."
42
+ #define CYTHON_HEX_VERSION 0x03000BF0
43
+ #define CYTHON_FUTURE_DIVISION 1
44
+ #include <stddef.h>
45
+ #ifndef offsetof
46
+ #define offsetof(type, member) ( (size_t) & ((type*)0) -> member )
47
+ #endif
48
+ #if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS)
49
+ #ifndef __stdcall
50
+ #define __stdcall
51
+ #endif
52
+ #ifndef __cdecl
53
+ #define __cdecl
54
+ #endif
55
+ #ifndef __fastcall
56
+ #define __fastcall
57
+ #endif
58
+ #endif
59
+ #ifndef DL_IMPORT
60
+ #define DL_IMPORT(t) t
61
+ #endif
62
+ #ifndef DL_EXPORT
63
+ #define DL_EXPORT(t) t
64
+ #endif
65
+ #define __PYX_COMMA ,
66
+ #ifndef HAVE_LONG_LONG
67
+ #define HAVE_LONG_LONG
68
+ #endif
69
+ #ifndef PY_LONG_LONG
70
+ #define PY_LONG_LONG LONG_LONG
71
+ #endif
72
+ #ifndef Py_HUGE_VAL
73
+ #define Py_HUGE_VAL HUGE_VAL
74
+ #endif
75
+ #define __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX
76
+ #if defined(GRAALVM_PYTHON)
77
+ /* For very preliminary testing purposes. Most variables are set the same as PyPy.
78
+ The existence of this section does not imply that anything works or is even tested */
79
+ #define CYTHON_COMPILING_IN_PYPY 0
80
+ #define CYTHON_COMPILING_IN_CPYTHON 0
81
+ #define CYTHON_COMPILING_IN_LIMITED_API 0
82
+ #define CYTHON_COMPILING_IN_GRAAL 1
83
+ #define CYTHON_COMPILING_IN_NOGIL 0
84
+ #undef CYTHON_USE_TYPE_SLOTS
85
+ #define CYTHON_USE_TYPE_SLOTS 0
86
+ #undef CYTHON_USE_TYPE_SPECS
87
+ #define CYTHON_USE_TYPE_SPECS 0
88
+ #undef CYTHON_USE_PYTYPE_LOOKUP
89
+ #define CYTHON_USE_PYTYPE_LOOKUP 0
90
+ #if PY_VERSION_HEX < 0x03050000
91
+ #undef CYTHON_USE_ASYNC_SLOTS
92
+ #define CYTHON_USE_ASYNC_SLOTS 0
93
+ #elif !defined(CYTHON_USE_ASYNC_SLOTS)
94
+ #define CYTHON_USE_ASYNC_SLOTS 1
95
+ #endif
96
+ #undef CYTHON_USE_PYLIST_INTERNALS
97
+ #define CYTHON_USE_PYLIST_INTERNALS 0
98
+ #undef CYTHON_USE_UNICODE_INTERNALS
99
+ #define CYTHON_USE_UNICODE_INTERNALS 0
100
+ #undef CYTHON_USE_UNICODE_WRITER
101
+ #define CYTHON_USE_UNICODE_WRITER 0
102
+ #undef CYTHON_USE_PYLONG_INTERNALS
103
+ #define CYTHON_USE_PYLONG_INTERNALS 0
104
+ #undef CYTHON_AVOID_BORROWED_REFS
105
+ #define CYTHON_AVOID_BORROWED_REFS 1
106
+ #undef CYTHON_ASSUME_SAFE_MACROS
107
+ #define CYTHON_ASSUME_SAFE_MACROS 0
108
+ #undef CYTHON_UNPACK_METHODS
109
+ #define CYTHON_UNPACK_METHODS 0
110
+ #undef CYTHON_FAST_THREAD_STATE
111
+ #define CYTHON_FAST_THREAD_STATE 0
112
+ #undef CYTHON_FAST_GIL
113
+ #define CYTHON_FAST_GIL 0
114
+ #undef CYTHON_METH_FASTCALL
115
+ #define CYTHON_METH_FASTCALL 0
116
+ #undef CYTHON_FAST_PYCALL
117
+ #define CYTHON_FAST_PYCALL 0
118
+ #ifndef CYTHON_PEP487_INIT_SUBCLASS
119
+ #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3)
120
+ #endif
121
+ #undef CYTHON_PEP489_MULTI_PHASE_INIT
122
+ #define CYTHON_PEP489_MULTI_PHASE_INIT 1
123
+ #undef CYTHON_USE_MODULE_STATE
124
+ #define CYTHON_USE_MODULE_STATE 0
125
+ #undef CYTHON_USE_TP_FINALIZE
126
+ #define CYTHON_USE_TP_FINALIZE 0
127
+ #undef CYTHON_USE_DICT_VERSIONS
128
+ #define CYTHON_USE_DICT_VERSIONS 0
129
+ #undef CYTHON_USE_EXC_INFO_STACK
130
+ #define CYTHON_USE_EXC_INFO_STACK 0
131
+ #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
132
+ #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
133
+ #endif
134
+ #undef CYTHON_USE_FREELISTS
135
+ #define CYTHON_USE_FREELISTS 0
136
+ #elif defined(PYPY_VERSION)
137
+ #define CYTHON_COMPILING_IN_PYPY 1
138
+ #define CYTHON_COMPILING_IN_CPYTHON 0
139
+ #define CYTHON_COMPILING_IN_LIMITED_API 0
140
+ #define CYTHON_COMPILING_IN_GRAAL 0
141
+ #define CYTHON_COMPILING_IN_NOGIL 0
142
+ #undef CYTHON_USE_TYPE_SLOTS
143
+ #define CYTHON_USE_TYPE_SLOTS 0
144
+ #ifndef CYTHON_USE_TYPE_SPECS
145
+ #define CYTHON_USE_TYPE_SPECS 0
146
+ #endif
147
+ #undef CYTHON_USE_PYTYPE_LOOKUP
148
+ #define CYTHON_USE_PYTYPE_LOOKUP 0
149
+ #if PY_VERSION_HEX < 0x03050000
150
+ #undef CYTHON_USE_ASYNC_SLOTS
151
+ #define CYTHON_USE_ASYNC_SLOTS 0
152
+ #elif !defined(CYTHON_USE_ASYNC_SLOTS)
153
+ #define CYTHON_USE_ASYNC_SLOTS 1
154
+ #endif
155
+ #undef CYTHON_USE_PYLIST_INTERNALS
156
+ #define CYTHON_USE_PYLIST_INTERNALS 0
157
+ #undef CYTHON_USE_UNICODE_INTERNALS
158
+ #define CYTHON_USE_UNICODE_INTERNALS 0
159
+ #undef CYTHON_USE_UNICODE_WRITER
160
+ #define CYTHON_USE_UNICODE_WRITER 0
161
+ #undef CYTHON_USE_PYLONG_INTERNALS
162
+ #define CYTHON_USE_PYLONG_INTERNALS 0
163
+ #undef CYTHON_AVOID_BORROWED_REFS
164
+ #define CYTHON_AVOID_BORROWED_REFS 1
165
+ #undef CYTHON_ASSUME_SAFE_MACROS
166
+ #define CYTHON_ASSUME_SAFE_MACROS 0
167
+ #undef CYTHON_UNPACK_METHODS
168
+ #define CYTHON_UNPACK_METHODS 0
169
+ #undef CYTHON_FAST_THREAD_STATE
170
+ #define CYTHON_FAST_THREAD_STATE 0
171
+ #undef CYTHON_FAST_GIL
172
+ #define CYTHON_FAST_GIL 0
173
+ #undef CYTHON_METH_FASTCALL
174
+ #define CYTHON_METH_FASTCALL 0
175
+ #undef CYTHON_FAST_PYCALL
176
+ #define CYTHON_FAST_PYCALL 0
177
+ #ifndef CYTHON_PEP487_INIT_SUBCLASS
178
+ #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3)
179
+ #endif
180
+ #if PY_VERSION_HEX < 0x03090000
181
+ #undef CYTHON_PEP489_MULTI_PHASE_INIT
182
+ #define CYTHON_PEP489_MULTI_PHASE_INIT 0
183
+ #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT)
184
+ #define CYTHON_PEP489_MULTI_PHASE_INIT 1
185
+ #endif
186
+ #undef CYTHON_USE_MODULE_STATE
187
+ #define CYTHON_USE_MODULE_STATE 0
188
+ #undef CYTHON_USE_TP_FINALIZE
189
+ #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1 && PYPY_VERSION_NUM >= 0x07030C00)
190
+ #undef CYTHON_USE_DICT_VERSIONS
191
+ #define CYTHON_USE_DICT_VERSIONS 0
192
+ #undef CYTHON_USE_EXC_INFO_STACK
193
+ #define CYTHON_USE_EXC_INFO_STACK 0
194
+ #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
195
+ #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
196
+ #endif
197
+ #undef CYTHON_USE_FREELISTS
198
+ #define CYTHON_USE_FREELISTS 0
199
+ #elif defined(CYTHON_LIMITED_API)
200
+ #ifdef Py_LIMITED_API
201
+ #undef __PYX_LIMITED_VERSION_HEX
202
+ #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API
203
+ #endif
204
+ #define CYTHON_COMPILING_IN_PYPY 0
205
+ #define CYTHON_COMPILING_IN_CPYTHON 0
206
+ #define CYTHON_COMPILING_IN_LIMITED_API 1
207
+ #define CYTHON_COMPILING_IN_GRAAL 0
208
+ #define CYTHON_COMPILING_IN_NOGIL 0
209
+ #undef CYTHON_CLINE_IN_TRACEBACK
210
+ #define CYTHON_CLINE_IN_TRACEBACK 0
211
+ #undef CYTHON_USE_TYPE_SLOTS
212
+ #define CYTHON_USE_TYPE_SLOTS 0
213
+ #undef CYTHON_USE_TYPE_SPECS
214
+ #define CYTHON_USE_TYPE_SPECS 1
215
+ #undef CYTHON_USE_PYTYPE_LOOKUP
216
+ #define CYTHON_USE_PYTYPE_LOOKUP 0
217
+ #undef CYTHON_USE_ASYNC_SLOTS
218
+ #define CYTHON_USE_ASYNC_SLOTS 0
219
+ #undef CYTHON_USE_PYLIST_INTERNALS
220
+ #define CYTHON_USE_PYLIST_INTERNALS 0
221
+ #undef CYTHON_USE_UNICODE_INTERNALS
222
+ #define CYTHON_USE_UNICODE_INTERNALS 0
223
+ #ifndef CYTHON_USE_UNICODE_WRITER
224
+ #define CYTHON_USE_UNICODE_WRITER 0
225
+ #endif
226
+ #undef CYTHON_USE_PYLONG_INTERNALS
227
+ #define CYTHON_USE_PYLONG_INTERNALS 0
228
+ #ifndef CYTHON_AVOID_BORROWED_REFS
229
+ #define CYTHON_AVOID_BORROWED_REFS 0
230
+ #endif
231
+ #undef CYTHON_ASSUME_SAFE_MACROS
232
+ #define CYTHON_ASSUME_SAFE_MACROS 0
233
+ #undef CYTHON_UNPACK_METHODS
234
+ #define CYTHON_UNPACK_METHODS 0
235
+ #undef CYTHON_FAST_THREAD_STATE
236
+ #define CYTHON_FAST_THREAD_STATE 0
237
+ #undef CYTHON_FAST_GIL
238
+ #define CYTHON_FAST_GIL 0
239
+ #undef CYTHON_METH_FASTCALL
240
+ #define CYTHON_METH_FASTCALL 0
241
+ #undef CYTHON_FAST_PYCALL
242
+ #define CYTHON_FAST_PYCALL 0
243
+ #ifndef CYTHON_PEP487_INIT_SUBCLASS
244
+ #define CYTHON_PEP487_INIT_SUBCLASS 1
245
+ #endif
246
+ #undef CYTHON_PEP489_MULTI_PHASE_INIT
247
+ #define CYTHON_PEP489_MULTI_PHASE_INIT 0
248
+ #undef CYTHON_USE_MODULE_STATE
249
+ #define CYTHON_USE_MODULE_STATE 1
250
+ #ifndef CYTHON_USE_TP_FINALIZE
251
+ #define CYTHON_USE_TP_FINALIZE 0
252
+ #endif
253
+ #undef CYTHON_USE_DICT_VERSIONS
254
+ #define CYTHON_USE_DICT_VERSIONS 0
255
+ #undef CYTHON_USE_EXC_INFO_STACK
256
+ #define CYTHON_USE_EXC_INFO_STACK 0
257
+ #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
258
+ #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
259
+ #endif
260
+ #undef CYTHON_USE_FREELISTS
261
+ #define CYTHON_USE_FREELISTS 0
262
+ #elif defined(Py_GIL_DISABLED) || defined(Py_NOGIL)
263
+ #define CYTHON_COMPILING_IN_PYPY 0
264
+ #define CYTHON_COMPILING_IN_CPYTHON 0
265
+ #define CYTHON_COMPILING_IN_LIMITED_API 0
266
+ #define CYTHON_COMPILING_IN_GRAAL 0
267
+ #define CYTHON_COMPILING_IN_NOGIL 1
268
+ #ifndef CYTHON_USE_TYPE_SLOTS
269
+ #define CYTHON_USE_TYPE_SLOTS 1
270
+ #endif
271
+ #ifndef CYTHON_USE_TYPE_SPECS
272
+ #define CYTHON_USE_TYPE_SPECS 0
273
+ #endif
274
+ #undef CYTHON_USE_PYTYPE_LOOKUP
275
+ #define CYTHON_USE_PYTYPE_LOOKUP 0
276
+ #ifndef CYTHON_USE_ASYNC_SLOTS
277
+ #define CYTHON_USE_ASYNC_SLOTS 1
278
+ #endif
279
+ #ifndef CYTHON_USE_PYLONG_INTERNALS
280
+ #define CYTHON_USE_PYLONG_INTERNALS 0
281
+ #endif
282
+ #undef CYTHON_USE_PYLIST_INTERNALS
283
+ #define CYTHON_USE_PYLIST_INTERNALS 0
284
+ #ifndef CYTHON_USE_UNICODE_INTERNALS
285
+ #define CYTHON_USE_UNICODE_INTERNALS 1
286
+ #endif
287
+ #undef CYTHON_USE_UNICODE_WRITER
288
+ #define CYTHON_USE_UNICODE_WRITER 0
289
+ #ifndef CYTHON_AVOID_BORROWED_REFS
290
+ #define CYTHON_AVOID_BORROWED_REFS 0
291
+ #endif
292
+ #ifndef CYTHON_ASSUME_SAFE_MACROS
293
+ #define CYTHON_ASSUME_SAFE_MACROS 1
294
+ #endif
295
+ #ifndef CYTHON_UNPACK_METHODS
296
+ #define CYTHON_UNPACK_METHODS 1
297
+ #endif
298
+ #undef CYTHON_FAST_THREAD_STATE
299
+ #define CYTHON_FAST_THREAD_STATE 0
300
+ #undef CYTHON_FAST_GIL
301
+ #define CYTHON_FAST_GIL 0
302
+ #ifndef CYTHON_METH_FASTCALL
303
+ #define CYTHON_METH_FASTCALL 1
304
+ #endif
305
+ #undef CYTHON_FAST_PYCALL
306
+ #define CYTHON_FAST_PYCALL 0
307
+ #ifndef CYTHON_PEP487_INIT_SUBCLASS
308
+ #define CYTHON_PEP487_INIT_SUBCLASS 1
309
+ #endif
310
+ #ifndef CYTHON_PEP489_MULTI_PHASE_INIT
311
+ #define CYTHON_PEP489_MULTI_PHASE_INIT 1
312
+ #endif
313
+ #ifndef CYTHON_USE_MODULE_STATE
314
+ #define CYTHON_USE_MODULE_STATE 0
315
+ #endif
316
+ #ifndef CYTHON_USE_TP_FINALIZE
317
+ #define CYTHON_USE_TP_FINALIZE 1
318
+ #endif
319
+ #undef CYTHON_USE_DICT_VERSIONS
320
+ #define CYTHON_USE_DICT_VERSIONS 0
321
+ #undef CYTHON_USE_EXC_INFO_STACK
322
+ #define CYTHON_USE_EXC_INFO_STACK 0
323
+ #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
324
+ #define CYTHON_UPDATE_DESCRIPTOR_DOC 1
325
+ #endif
326
+ #ifndef CYTHON_USE_FREELISTS
327
+ #define CYTHON_USE_FREELISTS 0
328
+ #endif
329
+ #else
330
+ #define CYTHON_COMPILING_IN_PYPY 0
331
+ #define CYTHON_COMPILING_IN_CPYTHON 1
332
+ #define CYTHON_COMPILING_IN_LIMITED_API 0
333
+ #define CYTHON_COMPILING_IN_GRAAL 0
334
+ #define CYTHON_COMPILING_IN_NOGIL 0
335
+ #ifndef CYTHON_USE_TYPE_SLOTS
336
+ #define CYTHON_USE_TYPE_SLOTS 1
337
+ #endif
338
+ #ifndef CYTHON_USE_TYPE_SPECS
339
+ #define CYTHON_USE_TYPE_SPECS 0
340
+ #endif
341
+ #ifndef CYTHON_USE_PYTYPE_LOOKUP
342
+ #define CYTHON_USE_PYTYPE_LOOKUP 1
343
+ #endif
344
+ #if PY_MAJOR_VERSION < 3
345
+ #undef CYTHON_USE_ASYNC_SLOTS
346
+ #define CYTHON_USE_ASYNC_SLOTS 0
347
+ #elif !defined(CYTHON_USE_ASYNC_SLOTS)
348
+ #define CYTHON_USE_ASYNC_SLOTS 1
349
+ #endif
350
+ #ifndef CYTHON_USE_PYLONG_INTERNALS
351
+ #define CYTHON_USE_PYLONG_INTERNALS 1
352
+ #endif
353
+ #ifndef CYTHON_USE_PYLIST_INTERNALS
354
+ #define CYTHON_USE_PYLIST_INTERNALS 1
355
+ #endif
356
+ #ifndef CYTHON_USE_UNICODE_INTERNALS
357
+ #define CYTHON_USE_UNICODE_INTERNALS 1
358
+ #endif
359
+ #if PY_VERSION_HEX < 0x030300F0 || PY_VERSION_HEX >= 0x030B00A2
360
+ #undef CYTHON_USE_UNICODE_WRITER
361
+ #define CYTHON_USE_UNICODE_WRITER 0
362
+ #elif !defined(CYTHON_USE_UNICODE_WRITER)
363
+ #define CYTHON_USE_UNICODE_WRITER 1
364
+ #endif
365
+ #ifndef CYTHON_AVOID_BORROWED_REFS
366
+ #define CYTHON_AVOID_BORROWED_REFS 0
367
+ #endif
368
+ #ifndef CYTHON_ASSUME_SAFE_MACROS
369
+ #define CYTHON_ASSUME_SAFE_MACROS 1
370
+ #endif
371
+ #ifndef CYTHON_UNPACK_METHODS
372
+ #define CYTHON_UNPACK_METHODS 1
373
+ #endif
374
+ #ifndef CYTHON_FAST_THREAD_STATE
375
+ #define CYTHON_FAST_THREAD_STATE 1
376
+ #endif
377
+ #ifndef CYTHON_FAST_GIL
378
+ #define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 || PY_VERSION_HEX >= 0x03060000 && PY_VERSION_HEX < 0x030C00A6)
379
+ #endif
380
+ #ifndef CYTHON_METH_FASTCALL
381
+ #define CYTHON_METH_FASTCALL (PY_VERSION_HEX >= 0x030700A1)
382
+ #endif
383
+ #ifndef CYTHON_FAST_PYCALL
384
+ #define CYTHON_FAST_PYCALL 1
385
+ #endif
386
+ #ifndef CYTHON_PEP487_INIT_SUBCLASS
387
+ #define CYTHON_PEP487_INIT_SUBCLASS 1
388
+ #endif
389
+ #if PY_VERSION_HEX < 0x03050000
390
+ #undef CYTHON_PEP489_MULTI_PHASE_INIT
391
+ #define CYTHON_PEP489_MULTI_PHASE_INIT 0
392
+ #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT)
393
+ #define CYTHON_PEP489_MULTI_PHASE_INIT 1
394
+ #endif
395
+ #ifndef CYTHON_USE_MODULE_STATE
396
+ #define CYTHON_USE_MODULE_STATE 0
397
+ #endif
398
+ #if PY_VERSION_HEX < 0x030400a1
399
+ #undef CYTHON_USE_TP_FINALIZE
400
+ #define CYTHON_USE_TP_FINALIZE 0
401
+ #elif !defined(CYTHON_USE_TP_FINALIZE)
402
+ #define CYTHON_USE_TP_FINALIZE 1
403
+ #endif
404
+ #if PY_VERSION_HEX < 0x030600B1
405
+ #undef CYTHON_USE_DICT_VERSIONS
406
+ #define CYTHON_USE_DICT_VERSIONS 0
407
+ #elif !defined(CYTHON_USE_DICT_VERSIONS)
408
+ #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX < 0x030C00A5)
409
+ #endif
410
+ #if PY_VERSION_HEX < 0x030700A3
411
+ #undef CYTHON_USE_EXC_INFO_STACK
412
+ #define CYTHON_USE_EXC_INFO_STACK 0
413
+ #elif !defined(CYTHON_USE_EXC_INFO_STACK)
414
+ #define CYTHON_USE_EXC_INFO_STACK 1
415
+ #endif
416
+ #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
417
+ #define CYTHON_UPDATE_DESCRIPTOR_DOC 1
418
+ #endif
419
+ #ifndef CYTHON_USE_FREELISTS
420
+ #define CYTHON_USE_FREELISTS 1
421
+ #endif
422
+ #endif
423
+ #if !defined(CYTHON_FAST_PYCCALL)
424
+ #define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1)
425
+ #endif
426
+ #if !defined(CYTHON_VECTORCALL)
427
+ #define CYTHON_VECTORCALL (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1)
428
+ #endif
429
+ #define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1)
430
+ #if CYTHON_USE_PYLONG_INTERNALS
431
+ #if PY_MAJOR_VERSION < 3
432
+ #include "longintrepr.h"
433
+ #endif
434
+ #undef SHIFT
435
+ #undef BASE
436
+ #undef MASK
437
+ #ifdef SIZEOF_VOID_P
438
+ enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) };
439
+ #endif
440
+ #endif
441
+ #ifndef __has_attribute
442
+ #define __has_attribute(x) 0
443
+ #endif
444
+ #ifndef __has_cpp_attribute
445
+ #define __has_cpp_attribute(x) 0
446
+ #endif
447
+ #ifndef CYTHON_RESTRICT
448
+ #if defined(__GNUC__)
449
+ #define CYTHON_RESTRICT __restrict__
450
+ #elif defined(_MSC_VER) && _MSC_VER >= 1400
451
+ #define CYTHON_RESTRICT __restrict
452
+ #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
453
+ #define CYTHON_RESTRICT restrict
454
+ #else
455
+ #define CYTHON_RESTRICT
456
+ #endif
457
+ #endif
458
+ #ifndef CYTHON_UNUSED
459
+ #if defined(__cplusplus)
460
+ /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17
461
+ * but leads to warnings with -pedantic, since it is a C++17 feature */
462
+ #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
463
+ #if __has_cpp_attribute(maybe_unused)
464
+ #define CYTHON_UNUSED [[maybe_unused]]
465
+ #endif
466
+ #endif
467
+ #endif
468
+ #endif
469
+ #ifndef CYTHON_UNUSED
470
+ # if defined(__GNUC__)
471
+ # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
472
+ # define CYTHON_UNUSED __attribute__ ((__unused__))
473
+ # else
474
+ # define CYTHON_UNUSED
475
+ # endif
476
+ # elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER))
477
+ # define CYTHON_UNUSED __attribute__ ((__unused__))
478
+ # else
479
+ # define CYTHON_UNUSED
480
+ # endif
481
+ #endif
482
+ #ifndef CYTHON_UNUSED_VAR
483
+ # if defined(__cplusplus)
484
+ template<class T> void CYTHON_UNUSED_VAR( const T& ) { }
485
+ # else
486
+ # define CYTHON_UNUSED_VAR(x) (void)(x)
487
+ # endif
488
+ #endif
489
+ #ifndef CYTHON_MAYBE_UNUSED_VAR
490
+ #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x)
491
+ #endif
492
+ #ifndef CYTHON_NCP_UNUSED
493
+ # if CYTHON_COMPILING_IN_CPYTHON
494
+ # define CYTHON_NCP_UNUSED
495
+ # else
496
+ # define CYTHON_NCP_UNUSED CYTHON_UNUSED
497
+ # endif
498
+ #endif
499
+ #ifndef CYTHON_USE_CPP_STD_MOVE
500
+ #if defined(__cplusplus) && (\
501
+ __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600))
502
+ #define CYTHON_USE_CPP_STD_MOVE 1
503
+ #else
504
+ #define CYTHON_USE_CPP_STD_MOVE 0
505
+ #endif
506
+ #endif
507
+ #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None)
508
+ #ifdef _MSC_VER
509
+ #ifndef _MSC_STDINT_H_
510
+ #if _MSC_VER < 1300
511
+ typedef unsigned char uint8_t;
512
+ typedef unsigned short uint16_t;
513
+ typedef unsigned int uint32_t;
514
+ #else
515
+ typedef unsigned __int8 uint8_t;
516
+ typedef unsigned __int16 uint16_t;
517
+ typedef unsigned __int32 uint32_t;
518
+ #endif
519
+ #endif
520
+ #if _MSC_VER < 1300
521
+ #ifdef _WIN64
522
+ typedef unsigned long long __pyx_uintptr_t;
523
+ #else
524
+ typedef unsigned int __pyx_uintptr_t;
525
+ #endif
526
+ #else
527
+ #ifdef _WIN64
528
+ typedef unsigned __int64 __pyx_uintptr_t;
529
+ #else
530
+ typedef unsigned __int32 __pyx_uintptr_t;
531
+ #endif
532
+ #endif
533
+ #else
534
+ #include <stdint.h>
535
+ typedef uintptr_t __pyx_uintptr_t;
536
+ #endif
537
+ #ifndef CYTHON_FALLTHROUGH
538
+ #if defined(__cplusplus)
539
+ /* for clang __has_cpp_attribute(fallthrough) is true even before C++17
540
+ * but leads to warnings with -pedantic, since it is a C++17 feature */
541
+ #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
542
+ #if __has_cpp_attribute(fallthrough)
543
+ #define CYTHON_FALLTHROUGH [[fallthrough]]
544
+ #endif
545
+ #endif
546
+ #ifndef CYTHON_FALLTHROUGH
547
+ #if __has_cpp_attribute(clang::fallthrough)
548
+ #define CYTHON_FALLTHROUGH [[clang::fallthrough]]
549
+ #elif __has_cpp_attribute(gnu::fallthrough)
550
+ #define CYTHON_FALLTHROUGH [[gnu::fallthrough]]
551
+ #endif
552
+ #endif
553
+ #endif
554
+ #ifndef CYTHON_FALLTHROUGH
555
+ #if __has_attribute(fallthrough)
556
+ #define CYTHON_FALLTHROUGH __attribute__((fallthrough))
557
+ #else
558
+ #define CYTHON_FALLTHROUGH
559
+ #endif
560
+ #endif
561
+ #if defined(__clang__) && defined(__apple_build_version__)
562
+ #if __apple_build_version__ < 7000000
563
+ #undef CYTHON_FALLTHROUGH
564
+ #define CYTHON_FALLTHROUGH
565
+ #endif
566
+ #endif
567
+ #endif
568
+ #ifdef __cplusplus
569
+ template <typename T>
570
+ struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);};
571
+ #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL<type>::value)
572
+ #else
573
+ #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0)
574
+ #endif
575
+ #if CYTHON_COMPILING_IN_PYPY == 1
576
+ #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000)
577
+ #else
578
+ #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000)
579
+ #endif
580
+ #define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer))
581
+
582
+ #ifndef CYTHON_INLINE
583
+ #if defined(__clang__)
584
+ #define CYTHON_INLINE __inline__ __attribute__ ((__unused__))
585
+ #elif defined(__GNUC__)
586
+ #define CYTHON_INLINE __inline__
587
+ #elif defined(_MSC_VER)
588
+ #define CYTHON_INLINE __inline
589
+ #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
590
+ #define CYTHON_INLINE inline
591
+ #else
592
+ #define CYTHON_INLINE
593
+ #endif
594
+ #endif
595
+
596
+ #define __PYX_BUILD_PY_SSIZE_T "n"
597
+ #define CYTHON_FORMAT_SSIZE_T "z"
598
+ #if PY_MAJOR_VERSION < 3
599
+ #define __Pyx_BUILTIN_MODULE_NAME "__builtin__"
600
+ #define __Pyx_DefaultClassType PyClass_Type
601
+ #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
602
+ PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
603
+ #else
604
+ #define __Pyx_BUILTIN_MODULE_NAME "builtins"
605
+ #define __Pyx_DefaultClassType PyType_Type
606
+ #if CYTHON_COMPILING_IN_LIMITED_API
607
+ static CYTHON_INLINE PyObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f,
608
+ PyObject *code, PyObject *c, PyObject* n, PyObject *v,
609
+ PyObject *fv, PyObject *cell, PyObject* fn,
610
+ PyObject *name, int fline, PyObject *lnos) {
611
+ PyObject *exception_table = NULL;
612
+ PyObject *types_module=NULL, *code_type=NULL, *result=NULL;
613
+ #if __PYX_LIMITED_VERSION_HEX < 0x030B0000
614
+ PyObject *version_info;
615
+ PyObject *py_minor_version = NULL;
616
+ #endif
617
+ long minor_version = 0;
618
+ PyObject *type, *value, *traceback;
619
+ PyErr_Fetch(&type, &value, &traceback);
620
+ #if __PYX_LIMITED_VERSION_HEX >= 0x030B0000
621
+ minor_version = 11;
622
+ #else
623
+ if (!(version_info = PySys_GetObject("version_info"))) goto end;
624
+ if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end;
625
+ minor_version = PyLong_AsLong(py_minor_version);
626
+ Py_DECREF(py_minor_version);
627
+ if (minor_version == -1 && PyErr_Occurred()) goto end;
628
+ #endif
629
+ if (!(types_module = PyImport_ImportModule("types"))) goto end;
630
+ if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end;
631
+ if (minor_version <= 7) {
632
+ (void)p;
633
+ result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOO", a, k, l, s, f, code,
634
+ c, n, v, fn, name, fline, lnos, fv, cell);
635
+ } else if (minor_version <= 10) {
636
+ result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOO", a,p, k, l, s, f, code,
637
+ c, n, v, fn, name, fline, lnos, fv, cell);
638
+ } else {
639
+ if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end;
640
+ result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOO", a,p, k, l, s, f, code,
641
+ c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell);
642
+ }
643
+ end:
644
+ Py_XDECREF(code_type);
645
+ Py_XDECREF(exception_table);
646
+ Py_XDECREF(types_module);
647
+ if (type) {
648
+ PyErr_Restore(type, value, traceback);
649
+ }
650
+ return result;
651
+ }
652
+ #ifndef CO_OPTIMIZED
653
+ #define CO_OPTIMIZED 0x0001
654
+ #endif
655
+ #ifndef CO_NEWLOCALS
656
+ #define CO_NEWLOCALS 0x0002
657
+ #endif
658
+ #ifndef CO_VARARGS
659
+ #define CO_VARARGS 0x0004
660
+ #endif
661
+ #ifndef CO_VARKEYWORDS
662
+ #define CO_VARKEYWORDS 0x0008
663
+ #endif
664
+ #ifndef CO_ASYNC_GENERATOR
665
+ #define CO_ASYNC_GENERATOR 0x0200
666
+ #endif
667
+ #ifndef CO_GENERATOR
668
+ #define CO_GENERATOR 0x0020
669
+ #endif
670
+ #ifndef CO_COROUTINE
671
+ #define CO_COROUTINE 0x0080
672
+ #endif
673
+ #elif PY_VERSION_HEX >= 0x030B0000
674
+ static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f,
675
+ PyObject *code, PyObject *c, PyObject* n, PyObject *v,
676
+ PyObject *fv, PyObject *cell, PyObject* fn,
677
+ PyObject *name, int fline, PyObject *lnos) {
678
+ PyCodeObject *result;
679
+ PyObject *empty_bytes = PyBytes_FromStringAndSize("", 0);
680
+ if (!empty_bytes) return NULL;
681
+ result =
682
+ #if PY_VERSION_HEX >= 0x030C0000
683
+ PyUnstable_Code_NewWithPosOnlyArgs
684
+ #else
685
+ PyCode_NewWithPosOnlyArgs
686
+ #endif
687
+ (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, empty_bytes);
688
+ Py_DECREF(empty_bytes);
689
+ return result;
690
+ }
691
+ #elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY
692
+ #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
693
+ PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
694
+ #else
695
+ #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
696
+ PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
697
+ #endif
698
+ #endif
699
+ #if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE)
700
+ #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type)
701
+ #else
702
+ #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type))
703
+ #endif
704
+ #if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is)
705
+ #define __Pyx_Py_Is(x, y) Py_Is(x, y)
706
+ #else
707
+ #define __Pyx_Py_Is(x, y) ((x) == (y))
708
+ #endif
709
+ #if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone)
710
+ #define __Pyx_Py_IsNone(ob) Py_IsNone(ob)
711
+ #else
712
+ #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None)
713
+ #endif
714
+ #if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue)
715
+ #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob)
716
+ #else
717
+ #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True)
718
+ #endif
719
+ #if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse)
720
+ #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob)
721
+ #else
722
+ #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False)
723
+ #endif
724
+ #define __Pyx_NoneAsNull(obj) (__Pyx_Py_IsNone(obj) ? NULL : (obj))
725
+ #if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY
726
+ #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o)
727
+ #else
728
+ #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o)
729
+ #endif
730
+ #ifndef CO_COROUTINE
731
+ #define CO_COROUTINE 0x80
732
+ #endif
733
+ #ifndef CO_ASYNC_GENERATOR
734
+ #define CO_ASYNC_GENERATOR 0x200
735
+ #endif
736
+ #ifndef Py_TPFLAGS_CHECKTYPES
737
+ #define Py_TPFLAGS_CHECKTYPES 0
738
+ #endif
739
+ #ifndef Py_TPFLAGS_HAVE_INDEX
740
+ #define Py_TPFLAGS_HAVE_INDEX 0
741
+ #endif
742
+ #ifndef Py_TPFLAGS_HAVE_NEWBUFFER
743
+ #define Py_TPFLAGS_HAVE_NEWBUFFER 0
744
+ #endif
745
+ #ifndef Py_TPFLAGS_HAVE_FINALIZE
746
+ #define Py_TPFLAGS_HAVE_FINALIZE 0
747
+ #endif
748
+ #ifndef Py_TPFLAGS_SEQUENCE
749
+ #define Py_TPFLAGS_SEQUENCE 0
750
+ #endif
751
+ #ifndef Py_TPFLAGS_MAPPING
752
+ #define Py_TPFLAGS_MAPPING 0
753
+ #endif
754
+ #ifndef METH_STACKLESS
755
+ #define METH_STACKLESS 0
756
+ #endif
757
+ #if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL)
758
+ #ifndef METH_FASTCALL
759
+ #define METH_FASTCALL 0x80
760
+ #endif
761
+ typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs);
762
+ typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args,
763
+ Py_ssize_t nargs, PyObject *kwnames);
764
+ #else
765
+ #if PY_VERSION_HEX >= 0x030d00A4
766
+ # define __Pyx_PyCFunctionFast PyCFunctionFast
767
+ # define __Pyx_PyCFunctionFastWithKeywords PyCFunctionFastWithKeywords
768
+ #else
769
+ # define __Pyx_PyCFunctionFast _PyCFunctionFast
770
+ # define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords
771
+ #endif
772
+ #endif
773
+ #if CYTHON_METH_FASTCALL
774
+ #define __Pyx_METH_FASTCALL METH_FASTCALL
775
+ #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast
776
+ #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords
777
+ #else
778
+ #define __Pyx_METH_FASTCALL METH_VARARGS
779
+ #define __Pyx_PyCFunction_FastCall PyCFunction
780
+ #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords
781
+ #endif
782
+ #if CYTHON_VECTORCALL
783
+ #define __pyx_vectorcallfunc vectorcallfunc
784
+ #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET PY_VECTORCALL_ARGUMENTS_OFFSET
785
+ #define __Pyx_PyVectorcall_NARGS(n) PyVectorcall_NARGS((size_t)(n))
786
+ #elif CYTHON_BACKPORT_VECTORCALL
787
+ typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args,
788
+ size_t nargsf, PyObject *kwnames);
789
+ #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET ((size_t)1 << (8 * sizeof(size_t) - 1))
790
+ #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET))
791
+ #else
792
+ #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET 0
793
+ #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(n))
794
+ #endif
795
+ #if PY_MAJOR_VERSION >= 0x030900B1
796
+ #define __Pyx_PyCFunction_CheckExact(func) PyCFunction_CheckExact(func)
797
+ #else
798
+ #define __Pyx_PyCFunction_CheckExact(func) PyCFunction_Check(func)
799
+ #endif
800
+ #define __Pyx_CyOrPyCFunction_Check(func) PyCFunction_Check(func)
801
+ #if CYTHON_COMPILING_IN_CPYTHON
802
+ #define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) (((PyCFunctionObject*)(func))->m_ml->ml_meth)
803
+ #elif !CYTHON_COMPILING_IN_LIMITED_API
804
+ #define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) PyCFunction_GET_FUNCTION(func)
805
+ #endif
806
+ #if CYTHON_COMPILING_IN_CPYTHON
807
+ #define __Pyx_CyOrPyCFunction_GET_FLAGS(func) (((PyCFunctionObject*)(func))->m_ml->ml_flags)
808
+ static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) {
809
+ return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self;
810
+ }
811
+ #endif
812
+ static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void *cfunc) {
813
+ #if CYTHON_COMPILING_IN_LIMITED_API
814
+ return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc;
815
+ #else
816
+ return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc;
817
+ #endif
818
+ }
819
+ #define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCFunction(func, cfunc)
820
+ #if __PYX_LIMITED_VERSION_HEX < 0x030900B1
821
+ #define __Pyx_PyType_FromModuleAndSpec(m, s, b) ((void)m, PyType_FromSpecWithBases(s, b))
822
+ typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *);
823
+ #else
824
+ #define __Pyx_PyType_FromModuleAndSpec(m, s, b) PyType_FromModuleAndSpec(m, s, b)
825
+ #define __Pyx_PyCMethod PyCMethod
826
+ #endif
827
+ #ifndef METH_METHOD
828
+ #define METH_METHOD 0x200
829
+ #endif
830
+ #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc)
831
+ #define PyObject_Malloc(s) PyMem_Malloc(s)
832
+ #define PyObject_Free(p) PyMem_Free(p)
833
+ #define PyObject_Realloc(p) PyMem_Realloc(p)
834
+ #endif
835
+ #if CYTHON_COMPILING_IN_LIMITED_API
836
+ #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0)
837
+ #define __Pyx_PyFrame_SetLineNumber(frame, lineno)
838
+ #else
839
+ #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0)
840
+ #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno)
841
+ #endif
842
+ #if CYTHON_COMPILING_IN_LIMITED_API
843
+ #define __Pyx_PyThreadState_Current PyThreadState_Get()
844
+ #elif !CYTHON_FAST_THREAD_STATE
845
+ #define __Pyx_PyThreadState_Current PyThreadState_GET()
846
+ #elif PY_VERSION_HEX >= 0x030d00A1
847
+ #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked()
848
+ #elif PY_VERSION_HEX >= 0x03060000
849
+ #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet()
850
+ #elif PY_VERSION_HEX >= 0x03000000
851
+ #define __Pyx_PyThreadState_Current PyThreadState_GET()
852
+ #else
853
+ #define __Pyx_PyThreadState_Current _PyThreadState_Current
854
+ #endif
855
+ #if CYTHON_COMPILING_IN_LIMITED_API
856
+ static CYTHON_INLINE void *__Pyx_PyModule_GetState(PyObject *op)
857
+ {
858
+ void *result;
859
+ result = PyModule_GetState(op);
860
+ if (!result)
861
+ Py_FatalError("Couldn't find the module state");
862
+ return result;
863
+ }
864
+ #endif
865
+ #define __Pyx_PyObject_GetSlot(obj, name, func_ctype) __Pyx_PyType_GetSlot(Py_TYPE(obj), name, func_ctype)
866
+ #if CYTHON_COMPILING_IN_LIMITED_API
867
+ #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((func_ctype) PyType_GetSlot((type), Py_##name))
868
+ #else
869
+ #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((type)->name)
870
+ #endif
871
+ #if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT)
872
+ #include "pythread.h"
873
+ #define Py_tss_NEEDS_INIT 0
874
+ typedef int Py_tss_t;
875
+ static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) {
876
+ *key = PyThread_create_key();
877
+ return 0;
878
+ }
879
+ static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) {
880
+ Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t));
881
+ *key = Py_tss_NEEDS_INIT;
882
+ return key;
883
+ }
884
+ static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) {
885
+ PyObject_Free(key);
886
+ }
887
+ static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) {
888
+ return *key != Py_tss_NEEDS_INIT;
889
+ }
890
+ static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) {
891
+ PyThread_delete_key(*key);
892
+ *key = Py_tss_NEEDS_INIT;
893
+ }
894
+ static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) {
895
+ return PyThread_set_key_value(*key, value);
896
+ }
897
+ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
898
+ return PyThread_get_key_value(*key);
899
+ }
900
+ #endif
901
+ #if PY_MAJOR_VERSION < 3
902
+ #if CYTHON_COMPILING_IN_PYPY
903
+ #if PYPY_VERSION_NUM < 0x07030600
904
+ #if defined(__cplusplus) && __cplusplus >= 201402L
905
+ [[deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")]]
906
+ #elif defined(__GNUC__) || defined(__clang__)
907
+ __attribute__ ((__deprecated__("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")))
908
+ #elif defined(_MSC_VER)
909
+ __declspec(deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6"))
910
+ #endif
911
+ static CYTHON_INLINE int PyGILState_Check(void) {
912
+ return 0;
913
+ }
914
+ #else // PYPY_VERSION_NUM < 0x07030600
915
+ #endif // PYPY_VERSION_NUM < 0x07030600
916
+ #else
917
+ static CYTHON_INLINE int PyGILState_Check(void) {
918
+ PyThreadState * tstate = _PyThreadState_Current;
919
+ return tstate && (tstate == PyGILState_GetThisThreadState());
920
+ }
921
+ #endif
922
+ #endif
923
+ #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 || defined(_PyDict_NewPresized)
924
+ #define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n))
925
+ #else
926
+ #define __Pyx_PyDict_NewPresized(n) PyDict_New()
927
+ #endif
928
+ #if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION
929
+ #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y)
930
+ #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y)
931
+ #else
932
+ #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y)
933
+ #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y)
934
+ #endif
935
+ #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX > 0x030600B4 && PY_VERSION_HEX < 0x030d0000 && CYTHON_USE_UNICODE_INTERNALS
936
+ #define __Pyx_PyDict_GetItemStrWithError(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash)
937
+ static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) {
938
+ PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name);
939
+ if (res == NULL) PyErr_Clear();
940
+ return res;
941
+ }
942
+ #elif PY_MAJOR_VERSION >= 3 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000)
943
+ #define __Pyx_PyDict_GetItemStrWithError PyDict_GetItemWithError
944
+ #define __Pyx_PyDict_GetItemStr PyDict_GetItem
945
+ #else
946
+ static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) {
947
+ #if CYTHON_COMPILING_IN_PYPY
948
+ return PyDict_GetItem(dict, name);
949
+ #else
950
+ PyDictEntry *ep;
951
+ PyDictObject *mp = (PyDictObject*) dict;
952
+ long hash = ((PyStringObject *) name)->ob_shash;
953
+ assert(hash != -1);
954
+ ep = (mp->ma_lookup)(mp, name, hash);
955
+ if (ep == NULL) {
956
+ return NULL;
957
+ }
958
+ return ep->me_value;
959
+ #endif
960
+ }
961
+ #define __Pyx_PyDict_GetItemStr PyDict_GetItem
962
+ #endif
963
+ #if CYTHON_USE_TYPE_SLOTS
964
+ #define __Pyx_PyType_GetFlags(tp) (((PyTypeObject *)tp)->tp_flags)
965
+ #define __Pyx_PyType_HasFeature(type, feature) ((__Pyx_PyType_GetFlags(type) & (feature)) != 0)
966
+ #define __Pyx_PyObject_GetIterNextFunc(obj) (Py_TYPE(obj)->tp_iternext)
967
+ #else
968
+ #define __Pyx_PyType_GetFlags(tp) (PyType_GetFlags((PyTypeObject *)tp))
969
+ #define __Pyx_PyType_HasFeature(type, feature) PyType_HasFeature(type, feature)
970
+ #define __Pyx_PyObject_GetIterNextFunc(obj) PyIter_Next
971
+ #endif
972
+ #if CYTHON_COMPILING_IN_LIMITED_API
973
+ #define __Pyx_SetItemOnTypeDict(tp, k, v) PyObject_GenericSetAttr((PyObject*)tp, k, v)
974
+ #else
975
+ #define __Pyx_SetItemOnTypeDict(tp, k, v) PyDict_SetItem(tp->tp_dict, k, v)
976
+ #endif
977
+ #if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX >= 0x03080000
978
+ #define __Pyx_PyHeapTypeObject_GC_Del(obj) {\
979
+ PyTypeObject *type = Py_TYPE((PyObject*)obj);\
980
+ assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\
981
+ PyObject_GC_Del(obj);\
982
+ Py_DECREF(type);\
983
+ }
984
+ #else
985
+ #define __Pyx_PyHeapTypeObject_GC_Del(obj) PyObject_GC_Del(obj)
986
+ #endif
987
+ #if CYTHON_COMPILING_IN_LIMITED_API
988
+ #define CYTHON_PEP393_ENABLED 1
989
+ #define __Pyx_PyUnicode_READY(op) (0)
990
+ #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GetLength(u)
991
+ #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i)
992
+ #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((void)u, 1114111U)
993
+ #define __Pyx_PyUnicode_KIND(u) ((void)u, (0))
994
+ #define __Pyx_PyUnicode_DATA(u) ((void*)u)
995
+ #define __Pyx_PyUnicode_READ(k, d, i) ((void)k, PyUnicode_ReadChar((PyObject*)(d), i))
996
+ #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GetLength(u))
997
+ #elif PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
998
+ #define CYTHON_PEP393_ENABLED 1
999
+ #if PY_VERSION_HEX >= 0x030C0000
1000
+ #define __Pyx_PyUnicode_READY(op) (0)
1001
+ #else
1002
+ #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\
1003
+ 0 : _PyUnicode_Ready((PyObject *)(op)))
1004
+ #endif
1005
+ #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u)
1006
+ #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i)
1007
+ #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u)
1008
+ #define __Pyx_PyUnicode_KIND(u) ((int)PyUnicode_KIND(u))
1009
+ #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u)
1010
+ #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i)
1011
+ #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, (Py_UCS4) ch)
1012
+ #if PY_VERSION_HEX >= 0x030C0000
1013
+ #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u))
1014
+ #else
1015
+ #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000
1016
+ #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length))
1017
+ #else
1018
+ #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
1019
+ #endif
1020
+ #endif
1021
+ #else
1022
+ #define CYTHON_PEP393_ENABLED 0
1023
+ #define PyUnicode_1BYTE_KIND 1
1024
+ #define PyUnicode_2BYTE_KIND 2
1025
+ #define PyUnicode_4BYTE_KIND 4
1026
+ #define __Pyx_PyUnicode_READY(op) (0)
1027
+ #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u)
1028
+ #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i]))
1029
+ #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535U : 1114111U)
1030
+ #define __Pyx_PyUnicode_KIND(u) ((int)sizeof(Py_UNICODE))
1031
+ #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u))
1032
+ #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i]))
1033
+ #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = (Py_UNICODE) ch)
1034
+ #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u))
1035
+ #endif
1036
+ #if CYTHON_COMPILING_IN_PYPY
1037
+ #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b)
1038
+ #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b)
1039
+ #else
1040
+ #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b)
1041
+ #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\
1042
+ PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b))
1043
+ #endif
1044
+ #if CYTHON_COMPILING_IN_PYPY
1045
+ #if !defined(PyUnicode_DecodeUnicodeEscape)
1046
+ #define PyUnicode_DecodeUnicodeEscape(s, size, errors) PyUnicode_Decode(s, size, "unicode_escape", errors)
1047
+ #endif
1048
+ #if !defined(PyUnicode_Contains) || (PY_MAJOR_VERSION == 2 && PYPY_VERSION_NUM < 0x07030500)
1049
+ #undef PyUnicode_Contains
1050
+ #define PyUnicode_Contains(u, s) PySequence_Contains(u, s)
1051
+ #endif
1052
+ #if !defined(PyByteArray_Check)
1053
+ #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type)
1054
+ #endif
1055
+ #if !defined(PyObject_Format)
1056
+ #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt)
1057
+ #endif
1058
+ #endif
1059
+ #define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b))
1060
+ #define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b))
1061
+ #if PY_MAJOR_VERSION >= 3
1062
+ #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b)
1063
+ #else
1064
+ #define __Pyx_PyString_Format(a, b) PyString_Format(a, b)
1065
+ #endif
1066
+ #if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII)
1067
+ #define PyObject_ASCII(o) PyObject_Repr(o)
1068
+ #endif
1069
+ #if PY_MAJOR_VERSION >= 3
1070
+ #define PyBaseString_Type PyUnicode_Type
1071
+ #define PyStringObject PyUnicodeObject
1072
+ #define PyString_Type PyUnicode_Type
1073
+ #define PyString_Check PyUnicode_Check
1074
+ #define PyString_CheckExact PyUnicode_CheckExact
1075
+ #ifndef PyObject_Unicode
1076
+ #define PyObject_Unicode PyObject_Str
1077
+ #endif
1078
+ #endif
1079
+ #if PY_MAJOR_VERSION >= 3
1080
+ #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj)
1081
+ #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj)
1082
+ #else
1083
+ #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj))
1084
+ #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj))
1085
+ #endif
1086
+ #if CYTHON_COMPILING_IN_CPYTHON
1087
+ #define __Pyx_PySequence_ListKeepNew(obj)\
1088
+ (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj))
1089
+ #else
1090
+ #define __Pyx_PySequence_ListKeepNew(obj) PySequence_List(obj)
1091
+ #endif
1092
+ #ifndef PySet_CheckExact
1093
+ #define PySet_CheckExact(obj) __Pyx_IS_TYPE(obj, &PySet_Type)
1094
+ #endif
1095
+ #if PY_VERSION_HEX >= 0x030900A4
1096
+ #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt)
1097
+ #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size)
1098
+ #else
1099
+ #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt)
1100
+ #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size)
1101
+ #endif
1102
+ #if CYTHON_ASSUME_SAFE_MACROS
1103
+ #define __Pyx_PySequence_ITEM(o, i) PySequence_ITEM(o, i)
1104
+ #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq)
1105
+ #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0))
1106
+ #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0))
1107
+ #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o)
1108
+ #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o)
1109
+ #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o)
1110
+ #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o)
1111
+ #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o)
1112
+ #else
1113
+ #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i)
1114
+ #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq)
1115
+ #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v)
1116
+ #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v)
1117
+ #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o)
1118
+ #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o)
1119
+ #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o)
1120
+ #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o)
1121
+ #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o)
1122
+ #endif
1123
+ #if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1
1124
+ #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name)
1125
+ #else
1126
+ static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) {
1127
+ PyObject *module = PyImport_AddModule(name);
1128
+ Py_XINCREF(module);
1129
+ return module;
1130
+ }
1131
+ #endif
1132
+ #if PY_MAJOR_VERSION >= 3
1133
+ #define PyIntObject PyLongObject
1134
+ #define PyInt_Type PyLong_Type
1135
+ #define PyInt_Check(op) PyLong_Check(op)
1136
+ #define PyInt_CheckExact(op) PyLong_CheckExact(op)
1137
+ #define __Pyx_Py3Int_Check(op) PyLong_Check(op)
1138
+ #define __Pyx_Py3Int_CheckExact(op) PyLong_CheckExact(op)
1139
+ #define PyInt_FromString PyLong_FromString
1140
+ #define PyInt_FromUnicode PyLong_FromUnicode
1141
+ #define PyInt_FromLong PyLong_FromLong
1142
+ #define PyInt_FromSize_t PyLong_FromSize_t
1143
+ #define PyInt_FromSsize_t PyLong_FromSsize_t
1144
+ #define PyInt_AsLong PyLong_AsLong
1145
+ #define PyInt_AS_LONG PyLong_AS_LONG
1146
+ #define PyInt_AsSsize_t PyLong_AsSsize_t
1147
+ #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask
1148
+ #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask
1149
+ #define PyNumber_Int PyNumber_Long
1150
+ #else
1151
+ #define __Pyx_Py3Int_Check(op) (PyLong_Check(op) || PyInt_Check(op))
1152
+ #define __Pyx_Py3Int_CheckExact(op) (PyLong_CheckExact(op) || PyInt_CheckExact(op))
1153
+ #endif
1154
+ #if PY_MAJOR_VERSION >= 3
1155
+ #define PyBoolObject PyLongObject
1156
+ #endif
1157
+ #if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY
1158
+ #ifndef PyUnicode_InternFromString
1159
+ #define PyUnicode_InternFromString(s) PyUnicode_FromString(s)
1160
+ #endif
1161
+ #endif
1162
+ #if PY_VERSION_HEX < 0x030200A4
1163
+ typedef long Py_hash_t;
1164
+ #define __Pyx_PyInt_FromHash_t PyInt_FromLong
1165
+ #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsHash_t
1166
+ #else
1167
+ #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t
1168
+ #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsSsize_t
1169
+ #endif
1170
+ #if CYTHON_USE_ASYNC_SLOTS
1171
+ #if PY_VERSION_HEX >= 0x030500B1
1172
+ #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods
1173
+ #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async)
1174
+ #else
1175
+ #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved))
1176
+ #endif
1177
+ #else
1178
+ #define __Pyx_PyType_AsAsync(obj) NULL
1179
+ #endif
1180
+ #ifndef __Pyx_PyAsyncMethodsStruct
1181
+ typedef struct {
1182
+ unaryfunc am_await;
1183
+ unaryfunc am_aiter;
1184
+ unaryfunc am_anext;
1185
+ } __Pyx_PyAsyncMethodsStruct;
1186
+ #endif
1187
+
1188
+ #if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS)
1189
+ #if !defined(_USE_MATH_DEFINES)
1190
+ #define _USE_MATH_DEFINES
1191
+ #endif
1192
+ #endif
1193
+ #include <math.h>
1194
+ #ifdef NAN
1195
+ #define __PYX_NAN() ((float) NAN)
1196
+ #else
1197
+ static CYTHON_INLINE float __PYX_NAN() {
1198
+ float value;
1199
+ memset(&value, 0xFF, sizeof(value));
1200
+ return value;
1201
+ }
1202
+ #endif
1203
+ #if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL)
1204
+ #define __Pyx_truncl trunc
1205
+ #else
1206
+ #define __Pyx_truncl truncl
1207
+ #endif
1208
+
1209
+ #define __PYX_MARK_ERR_POS(f_index, lineno) \
1210
+ { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; }
1211
+ #define __PYX_ERR(f_index, lineno, Ln_error) \
1212
+ { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; }
1213
+
1214
+ #ifdef CYTHON_EXTERN_C
1215
+ #undef __PYX_EXTERN_C
1216
+ #define __PYX_EXTERN_C CYTHON_EXTERN_C
1217
+ #elif defined(__PYX_EXTERN_C)
1218
+ #ifdef _MSC_VER
1219
+ #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.")
1220
+ #else
1221
+ #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.
1222
+ #endif
1223
+ #else
1224
+ #ifdef __cplusplus
1225
+ #define __PYX_EXTERN_C extern "C"
1226
+ #else
1227
+ #define __PYX_EXTERN_C extern
1228
+ #endif
1229
+ #endif
1230
+
1231
+ #define __PYX_HAVE__webview___dummy_holder
1232
+ #define __PYX_HAVE_API__webview___dummy_holder
1233
+ /* Early includes */
1234
+ #ifdef _OPENMP
1235
+ #include <omp.h>
1236
+ #endif /* _OPENMP */
1237
+
1238
+ #if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS)
1239
+ #define CYTHON_WITHOUT_ASSERTIONS
1240
+ #endif
1241
+
1242
+ typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding;
1243
+ const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry;
1244
+
1245
+ #define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0
1246
+ #define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0
1247
+ #define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8)
1248
+ #define __PYX_DEFAULT_STRING_ENCODING ""
1249
+ #define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString
1250
+ #define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize
1251
+ #define __Pyx_uchar_cast(c) ((unsigned char)c)
1252
+ #define __Pyx_long_cast(x) ((long)x)
1253
+ #define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\
1254
+ (sizeof(type) < sizeof(Py_ssize_t)) ||\
1255
+ (sizeof(type) > sizeof(Py_ssize_t) &&\
1256
+ likely(v < (type)PY_SSIZE_T_MAX ||\
1257
+ v == (type)PY_SSIZE_T_MAX) &&\
1258
+ (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\
1259
+ v == (type)PY_SSIZE_T_MIN))) ||\
1260
+ (sizeof(type) == sizeof(Py_ssize_t) &&\
1261
+ (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\
1262
+ v == (type)PY_SSIZE_T_MAX))) )
1263
+ static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) {
1264
+ return (size_t) i < (size_t) limit;
1265
+ }
1266
+ #if defined (__cplusplus) && __cplusplus >= 201103L
1267
+ #include <cstdlib>
1268
+ #define __Pyx_sst_abs(value) std::abs(value)
1269
+ #elif SIZEOF_INT >= SIZEOF_SIZE_T
1270
+ #define __Pyx_sst_abs(value) abs(value)
1271
+ #elif SIZEOF_LONG >= SIZEOF_SIZE_T
1272
+ #define __Pyx_sst_abs(value) labs(value)
1273
+ #elif defined (_MSC_VER)
1274
+ #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value))
1275
+ #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
1276
+ #define __Pyx_sst_abs(value) llabs(value)
1277
+ #elif defined (__GNUC__)
1278
+ #define __Pyx_sst_abs(value) __builtin_llabs(value)
1279
+ #else
1280
+ #define __Pyx_sst_abs(value) ((value<0) ? -value : value)
1281
+ #endif
1282
+ static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s);
1283
+ static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*);
1284
+ static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length);
1285
+ static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*);
1286
+ #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l)
1287
+ #define __Pyx_PyBytes_FromString PyBytes_FromString
1288
+ #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize
1289
+ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
1290
+ #if PY_MAJOR_VERSION < 3
1291
+ #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString
1292
+ #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize
1293
+ #else
1294
+ #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString
1295
+ #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize
1296
+ #endif
1297
+ #define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s))
1298
+ #define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s))
1299
+ #define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s))
1300
+ #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s))
1301
+ #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s))
1302
+ #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s))
1303
+ #define __Pyx_PyObject_AsWritableString(s) ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
1304
+ #define __Pyx_PyObject_AsWritableSString(s) ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
1305
+ #define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
1306
+ #define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s))
1307
+ #define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s))
1308
+ #define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s)
1309
+ #define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s)
1310
+ #define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s)
1311
+ #define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s)
1312
+ #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s)
1313
+ #define __Pyx_PyUnicode_FromOrdinal(o) PyUnicode_FromOrdinal((int)o)
1314
+ #define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode
1315
+ #define __Pyx_NewRef(obj) (Py_INCREF(obj), obj)
1316
+ #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None)
1317
+ static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b);
1318
+ static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*);
1319
+ static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*);
1320
+ static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x);
1321
+ #define __Pyx_PySequence_Tuple(obj)\
1322
+ (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj))
1323
+ static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*);
1324
+ static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t);
1325
+ static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*);
1326
+ #if CYTHON_ASSUME_SAFE_MACROS
1327
+ #define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x))
1328
+ #else
1329
+ #define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x)
1330
+ #endif
1331
+ #define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x))
1332
+ #if PY_MAJOR_VERSION >= 3
1333
+ #define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x))
1334
+ #else
1335
+ #define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x))
1336
+ #endif
1337
+ #if CYTHON_USE_PYLONG_INTERNALS
1338
+ #if PY_VERSION_HEX >= 0x030C00A7
1339
+ #ifndef _PyLong_SIGN_MASK
1340
+ #define _PyLong_SIGN_MASK 3
1341
+ #endif
1342
+ #ifndef _PyLong_NON_SIZE_BITS
1343
+ #define _PyLong_NON_SIZE_BITS 3
1344
+ #endif
1345
+ #define __Pyx_PyLong_Sign(x) (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK)
1346
+ #define __Pyx_PyLong_IsNeg(x) ((__Pyx_PyLong_Sign(x) & 2) != 0)
1347
+ #define __Pyx_PyLong_IsNonNeg(x) (!__Pyx_PyLong_IsNeg(x))
1348
+ #define __Pyx_PyLong_IsZero(x) (__Pyx_PyLong_Sign(x) & 1)
1349
+ #define __Pyx_PyLong_IsPos(x) (__Pyx_PyLong_Sign(x) == 0)
1350
+ #define __Pyx_PyLong_CompactValueUnsigned(x) (__Pyx_PyLong_Digits(x)[0])
1351
+ #define __Pyx_PyLong_DigitCount(x) ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS))
1352
+ #define __Pyx_PyLong_SignedDigitCount(x)\
1353
+ ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x))
1354
+ #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue)
1355
+ #define __Pyx_PyLong_IsCompact(x) PyUnstable_Long_IsCompact((PyLongObject*) x)
1356
+ #define __Pyx_PyLong_CompactValue(x) PyUnstable_Long_CompactValue((PyLongObject*) x)
1357
+ #else
1358
+ #define __Pyx_PyLong_IsCompact(x) (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS))
1359
+ #define __Pyx_PyLong_CompactValue(x) ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0])
1360
+ #endif
1361
+ typedef Py_ssize_t __Pyx_compact_pylong;
1362
+ typedef size_t __Pyx_compact_upylong;
1363
+ #else
1364
+ #define __Pyx_PyLong_IsNeg(x) (Py_SIZE(x) < 0)
1365
+ #define __Pyx_PyLong_IsNonNeg(x) (Py_SIZE(x) >= 0)
1366
+ #define __Pyx_PyLong_IsZero(x) (Py_SIZE(x) == 0)
1367
+ #define __Pyx_PyLong_IsPos(x) (Py_SIZE(x) > 0)
1368
+ #define __Pyx_PyLong_CompactValueUnsigned(x) ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0])
1369
+ #define __Pyx_PyLong_DigitCount(x) __Pyx_sst_abs(Py_SIZE(x))
1370
+ #define __Pyx_PyLong_SignedDigitCount(x) Py_SIZE(x)
1371
+ #define __Pyx_PyLong_IsCompact(x) (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1)
1372
+ #define __Pyx_PyLong_CompactValue(x)\
1373
+ ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0]))
1374
+ typedef sdigit __Pyx_compact_pylong;
1375
+ typedef digit __Pyx_compact_upylong;
1376
+ #endif
1377
+ #if PY_VERSION_HEX >= 0x030C00A5
1378
+ #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->long_value.ob_digit)
1379
+ #else
1380
+ #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->ob_digit)
1381
+ #endif
1382
+ #endif
1383
+ #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
1384
+ #include <string.h>
1385
+ static int __Pyx_sys_getdefaultencoding_not_ascii;
1386
+ static int __Pyx_init_sys_getdefaultencoding_params(void) {
1387
+ PyObject* sys;
1388
+ PyObject* default_encoding = NULL;
1389
+ PyObject* ascii_chars_u = NULL;
1390
+ PyObject* ascii_chars_b = NULL;
1391
+ const char* default_encoding_c;
1392
+ sys = PyImport_ImportModule("sys");
1393
+ if (!sys) goto bad;
1394
+ default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL);
1395
+ Py_DECREF(sys);
1396
+ if (!default_encoding) goto bad;
1397
+ default_encoding_c = PyBytes_AsString(default_encoding);
1398
+ if (!default_encoding_c) goto bad;
1399
+ if (strcmp(default_encoding_c, "ascii") == 0) {
1400
+ __Pyx_sys_getdefaultencoding_not_ascii = 0;
1401
+ } else {
1402
+ char ascii_chars[128];
1403
+ int c;
1404
+ for (c = 0; c < 128; c++) {
1405
+ ascii_chars[c] = (char) c;
1406
+ }
1407
+ __Pyx_sys_getdefaultencoding_not_ascii = 1;
1408
+ ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL);
1409
+ if (!ascii_chars_u) goto bad;
1410
+ ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL);
1411
+ if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) {
1412
+ PyErr_Format(
1413
+ PyExc_ValueError,
1414
+ "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.",
1415
+ default_encoding_c);
1416
+ goto bad;
1417
+ }
1418
+ Py_DECREF(ascii_chars_u);
1419
+ Py_DECREF(ascii_chars_b);
1420
+ }
1421
+ Py_DECREF(default_encoding);
1422
+ return 0;
1423
+ bad:
1424
+ Py_XDECREF(default_encoding);
1425
+ Py_XDECREF(ascii_chars_u);
1426
+ Py_XDECREF(ascii_chars_b);
1427
+ return -1;
1428
+ }
1429
+ #endif
1430
+ #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3
1431
+ #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL)
1432
+ #else
1433
+ #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL)
1434
+ #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
1435
+ #include <string.h>
1436
+ static char* __PYX_DEFAULT_STRING_ENCODING;
1437
+ static int __Pyx_init_sys_getdefaultencoding_params(void) {
1438
+ PyObject* sys;
1439
+ PyObject* default_encoding = NULL;
1440
+ char* default_encoding_c;
1441
+ sys = PyImport_ImportModule("sys");
1442
+ if (!sys) goto bad;
1443
+ default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL);
1444
+ Py_DECREF(sys);
1445
+ if (!default_encoding) goto bad;
1446
+ default_encoding_c = PyBytes_AsString(default_encoding);
1447
+ if (!default_encoding_c) goto bad;
1448
+ __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1);
1449
+ if (!__PYX_DEFAULT_STRING_ENCODING) goto bad;
1450
+ strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c);
1451
+ Py_DECREF(default_encoding);
1452
+ return 0;
1453
+ bad:
1454
+ Py_XDECREF(default_encoding);
1455
+ return -1;
1456
+ }
1457
+ #endif
1458
+ #endif
1459
+
1460
+
1461
+ /* Test for GCC > 2.95 */
1462
+ #if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))
1463
+ #define likely(x) __builtin_expect(!!(x), 1)
1464
+ #define unlikely(x) __builtin_expect(!!(x), 0)
1465
+ #else /* !__GNUC__ or GCC < 2.95 */
1466
+ #define likely(x) (x)
1467
+ #define unlikely(x) (x)
1468
+ #endif /* __GNUC__ */
1469
+ static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; }
1470
+
1471
+ #if !CYTHON_USE_MODULE_STATE
1472
+ static PyObject *__pyx_m = NULL;
1473
+ #endif
1474
+ static int __pyx_lineno;
1475
+ static int __pyx_clineno = 0;
1476
+ static const char * __pyx_cfilenm = __FILE__;
1477
+ static const char *__pyx_filename;
1478
+
1479
+ /* #### Code section: filename_table ### */
1480
+
1481
+ static const char *__pyx_f[] = {
1482
+ "src\\\\webview\\\\_dummy_holder.pyx",
1483
+ };
1484
+ /* #### Code section: utility_code_proto_before_types ### */
1485
+ /* #### Code section: numeric_typedefs ### */
1486
+ /* #### Code section: complex_type_declarations ### */
1487
+ /* #### Code section: type_declarations ### */
1488
+
1489
+ /*--- Type declarations ---*/
1490
+ /* #### Code section: utility_code_proto ### */
1491
+
1492
+ /* --- Runtime support code (head) --- */
1493
+ /* Refnanny.proto */
1494
+ #ifndef CYTHON_REFNANNY
1495
+ #define CYTHON_REFNANNY 0
1496
+ #endif
1497
+ #if CYTHON_REFNANNY
1498
+ typedef struct {
1499
+ void (*INCREF)(void*, PyObject*, Py_ssize_t);
1500
+ void (*DECREF)(void*, PyObject*, Py_ssize_t);
1501
+ void (*GOTREF)(void*, PyObject*, Py_ssize_t);
1502
+ void (*GIVEREF)(void*, PyObject*, Py_ssize_t);
1503
+ void* (*SetupContext)(const char*, Py_ssize_t, const char*);
1504
+ void (*FinishContext)(void**);
1505
+ } __Pyx_RefNannyAPIStruct;
1506
+ static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL;
1507
+ static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname);
1508
+ #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL;
1509
+ #ifdef WITH_THREAD
1510
+ #define __Pyx_RefNannySetupContext(name, acquire_gil)\
1511
+ if (acquire_gil) {\
1512
+ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
1513
+ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\
1514
+ PyGILState_Release(__pyx_gilstate_save);\
1515
+ } else {\
1516
+ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\
1517
+ }
1518
+ #define __Pyx_RefNannyFinishContextNogil() {\
1519
+ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
1520
+ __Pyx_RefNannyFinishContext();\
1521
+ PyGILState_Release(__pyx_gilstate_save);\
1522
+ }
1523
+ #else
1524
+ #define __Pyx_RefNannySetupContext(name, acquire_gil)\
1525
+ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__))
1526
+ #define __Pyx_RefNannyFinishContextNogil() __Pyx_RefNannyFinishContext()
1527
+ #endif
1528
+ #define __Pyx_RefNannyFinishContextNogil() {\
1529
+ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
1530
+ __Pyx_RefNannyFinishContext();\
1531
+ PyGILState_Release(__pyx_gilstate_save);\
1532
+ }
1533
+ #define __Pyx_RefNannyFinishContext()\
1534
+ __Pyx_RefNanny->FinishContext(&__pyx_refnanny)
1535
+ #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
1536
+ #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
1537
+ #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
1538
+ #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
1539
+ #define __Pyx_XINCREF(r) do { if((r) == NULL); else {__Pyx_INCREF(r); }} while(0)
1540
+ #define __Pyx_XDECREF(r) do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0)
1541
+ #define __Pyx_XGOTREF(r) do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0)
1542
+ #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0)
1543
+ #else
1544
+ #define __Pyx_RefNannyDeclarations
1545
+ #define __Pyx_RefNannySetupContext(name, acquire_gil)
1546
+ #define __Pyx_RefNannyFinishContextNogil()
1547
+ #define __Pyx_RefNannyFinishContext()
1548
+ #define __Pyx_INCREF(r) Py_INCREF(r)
1549
+ #define __Pyx_DECREF(r) Py_DECREF(r)
1550
+ #define __Pyx_GOTREF(r)
1551
+ #define __Pyx_GIVEREF(r)
1552
+ #define __Pyx_XINCREF(r) Py_XINCREF(r)
1553
+ #define __Pyx_XDECREF(r) Py_XDECREF(r)
1554
+ #define __Pyx_XGOTREF(r)
1555
+ #define __Pyx_XGIVEREF(r)
1556
+ #endif
1557
+ #define __Pyx_Py_XDECREF_SET(r, v) do {\
1558
+ PyObject *tmp = (PyObject *) r;\
1559
+ r = v; Py_XDECREF(tmp);\
1560
+ } while (0)
1561
+ #define __Pyx_XDECREF_SET(r, v) do {\
1562
+ PyObject *tmp = (PyObject *) r;\
1563
+ r = v; __Pyx_XDECREF(tmp);\
1564
+ } while (0)
1565
+ #define __Pyx_DECREF_SET(r, v) do {\
1566
+ PyObject *tmp = (PyObject *) r;\
1567
+ r = v; __Pyx_DECREF(tmp);\
1568
+ } while (0)
1569
+ #define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0)
1570
+ #define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0)
1571
+
1572
+ /* PyDictVersioning.proto */
1573
+ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
1574
+ #define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1)
1575
+ #define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag)
1576
+ #define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\
1577
+ (version_var) = __PYX_GET_DICT_VERSION(dict);\
1578
+ (cache_var) = (value);
1579
+ #define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\
1580
+ static PY_UINT64_T __pyx_dict_version = 0;\
1581
+ static PyObject *__pyx_dict_cached_value = NULL;\
1582
+ if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\
1583
+ (VAR) = __pyx_dict_cached_value;\
1584
+ } else {\
1585
+ (VAR) = __pyx_dict_cached_value = (LOOKUP);\
1586
+ __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\
1587
+ }\
1588
+ }
1589
+ static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj);
1590
+ static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj);
1591
+ static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version);
1592
+ #else
1593
+ #define __PYX_GET_DICT_VERSION(dict) (0)
1594
+ #define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)
1595
+ #define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP);
1596
+ #endif
1597
+
1598
+ /* PyErrExceptionMatches.proto */
1599
+ #if CYTHON_FAST_THREAD_STATE
1600
+ #define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err)
1601
+ static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err);
1602
+ #else
1603
+ #define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err)
1604
+ #endif
1605
+
1606
+ /* PyThreadStateGet.proto */
1607
+ #if CYTHON_FAST_THREAD_STATE
1608
+ #define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate;
1609
+ #define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current;
1610
+ #if PY_VERSION_HEX >= 0x030C00A6
1611
+ #define __Pyx_PyErr_Occurred() (__pyx_tstate->current_exception != NULL)
1612
+ #define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL)
1613
+ #else
1614
+ #define __Pyx_PyErr_Occurred() (__pyx_tstate->curexc_type != NULL)
1615
+ #define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->curexc_type)
1616
+ #endif
1617
+ #else
1618
+ #define __Pyx_PyThreadState_declare
1619
+ #define __Pyx_PyThreadState_assign
1620
+ #define __Pyx_PyErr_Occurred() (PyErr_Occurred() != NULL)
1621
+ #define __Pyx_PyErr_CurrentExceptionType() PyErr_Occurred()
1622
+ #endif
1623
+
1624
+ /* PyErrFetchRestore.proto */
1625
+ #if CYTHON_FAST_THREAD_STATE
1626
+ #define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL)
1627
+ #define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb)
1628
+ #define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb)
1629
+ #define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb)
1630
+ #define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb)
1631
+ static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
1632
+ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
1633
+ #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6
1634
+ #define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL))
1635
+ #else
1636
+ #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
1637
+ #endif
1638
+ #else
1639
+ #define __Pyx_PyErr_Clear() PyErr_Clear()
1640
+ #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
1641
+ #define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb)
1642
+ #define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb)
1643
+ #define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb)
1644
+ #define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb)
1645
+ #define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb)
1646
+ #define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb)
1647
+ #endif
1648
+
1649
+ /* PyObjectGetAttrStr.proto */
1650
+ #if CYTHON_USE_TYPE_SLOTS
1651
+ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name);
1652
+ #else
1653
+ #define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
1654
+ #endif
1655
+
1656
+ /* PyObjectGetAttrStrNoError.proto */
1657
+ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name);
1658
+
1659
+ /* CLineInTraceback.proto */
1660
+ #ifdef CYTHON_CLINE_IN_TRACEBACK
1661
+ #define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0)
1662
+ #else
1663
+ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line);
1664
+ #endif
1665
+
1666
+ /* CodeObjectCache.proto */
1667
+ #if !CYTHON_COMPILING_IN_LIMITED_API
1668
+ typedef struct {
1669
+ PyCodeObject* code_object;
1670
+ int code_line;
1671
+ } __Pyx_CodeObjectCacheEntry;
1672
+ struct __Pyx_CodeObjectCache {
1673
+ int count;
1674
+ int max_count;
1675
+ __Pyx_CodeObjectCacheEntry* entries;
1676
+ };
1677
+ static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL};
1678
+ static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line);
1679
+ static PyCodeObject *__pyx_find_code_object(int code_line);
1680
+ static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object);
1681
+ #endif
1682
+
1683
+ /* AddTraceback.proto */
1684
+ static void __Pyx_AddTraceback(const char *funcname, int c_line,
1685
+ int py_line, const char *filename);
1686
+
1687
+ /* FormatTypeName.proto */
1688
+ #if CYTHON_COMPILING_IN_LIMITED_API
1689
+ typedef PyObject *__Pyx_TypeName;
1690
+ #define __Pyx_FMT_TYPENAME "%U"
1691
+ static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp);
1692
+ #define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj)
1693
+ #else
1694
+ typedef const char *__Pyx_TypeName;
1695
+ #define __Pyx_FMT_TYPENAME "%.200s"
1696
+ #define __Pyx_PyType_GetName(tp) ((tp)->tp_name)
1697
+ #define __Pyx_DECREF_TypeName(obj)
1698
+ #endif
1699
+
1700
+ /* GCCDiagnostics.proto */
1701
+ #if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
1702
+ #define __Pyx_HAS_GCC_DIAGNOSTIC
1703
+ #endif
1704
+
1705
+ /* CIntToPy.proto */
1706
+ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value);
1707
+
1708
+ /* CIntFromPy.proto */
1709
+ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *);
1710
+
1711
+ /* CIntFromPy.proto */
1712
+ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *);
1713
+
1714
+ /* FastTypeChecks.proto */
1715
+ #if CYTHON_COMPILING_IN_CPYTHON
1716
+ #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type)
1717
+ #define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2)
1718
+ static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b);
1719
+ static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b);
1720
+ static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type);
1721
+ static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2);
1722
+ #else
1723
+ #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type)
1724
+ #define __Pyx_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2))
1725
+ #define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type)
1726
+ #define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2))
1727
+ #endif
1728
+ #define __Pyx_PyErr_ExceptionMatches2(err1, err2) __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2)
1729
+ #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception)
1730
+
1731
+ /* CheckBinaryVersion.proto */
1732
+ static unsigned long __Pyx_get_runtime_version(void);
1733
+ static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer);
1734
+
1735
+ /* InitStrings.proto */
1736
+ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t);
1737
+
1738
+ /* #### Code section: module_declarations ### */
1739
+
1740
+ /* Module declarations from "webview._dummy_holder" */
1741
+ /* #### Code section: typeinfo ### */
1742
+ /* #### Code section: before_global_var ### */
1743
+ #define __Pyx_MODULE_NAME "webview._dummy_holder"
1744
+ extern int __pyx_module_is_main_webview___dummy_holder;
1745
+ int __pyx_module_is_main_webview___dummy_holder = 0;
1746
+
1747
+ /* Implementation of "webview._dummy_holder" */
1748
+ /* #### Code section: global_var ### */
1749
+ /* #### Code section: string_decls ### */
1750
+ static const char __pyx_k_[] = "?";
1751
+ static const char __pyx_k_main[] = "__main__";
1752
+ static const char __pyx_k_name[] = "__name__";
1753
+ static const char __pyx_k_test[] = "__test__";
1754
+ static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback";
1755
+ /* #### Code section: decls ### */
1756
+ /* #### Code section: late_includes ### */
1757
+ /* #### Code section: module_state ### */
1758
+ typedef struct {
1759
+ PyObject *__pyx_d;
1760
+ PyObject *__pyx_b;
1761
+ PyObject *__pyx_cython_runtime;
1762
+ PyObject *__pyx_empty_tuple;
1763
+ PyObject *__pyx_empty_bytes;
1764
+ PyObject *__pyx_empty_unicode;
1765
+ #ifdef __Pyx_CyFunction_USED
1766
+ PyTypeObject *__pyx_CyFunctionType;
1767
+ #endif
1768
+ #ifdef __Pyx_FusedFunction_USED
1769
+ PyTypeObject *__pyx_FusedFunctionType;
1770
+ #endif
1771
+ #ifdef __Pyx_Generator_USED
1772
+ PyTypeObject *__pyx_GeneratorType;
1773
+ #endif
1774
+ #ifdef __Pyx_IterableCoroutine_USED
1775
+ PyTypeObject *__pyx_IterableCoroutineType;
1776
+ #endif
1777
+ #ifdef __Pyx_Coroutine_USED
1778
+ PyTypeObject *__pyx_CoroutineAwaitType;
1779
+ #endif
1780
+ #ifdef __Pyx_Coroutine_USED
1781
+ PyTypeObject *__pyx_CoroutineType;
1782
+ #endif
1783
+ #if CYTHON_USE_MODULE_STATE
1784
+ #endif
1785
+ PyObject *__pyx_n_s_;
1786
+ PyObject *__pyx_n_s_cline_in_traceback;
1787
+ PyObject *__pyx_n_s_main;
1788
+ PyObject *__pyx_n_s_name;
1789
+ PyObject *__pyx_n_s_test;
1790
+ } __pyx_mstate;
1791
+
1792
+ #if CYTHON_USE_MODULE_STATE
1793
+ #ifdef __cplusplus
1794
+ namespace {
1795
+ extern struct PyModuleDef __pyx_moduledef;
1796
+ } /* anonymous namespace */
1797
+ #else
1798
+ static struct PyModuleDef __pyx_moduledef;
1799
+ #endif
1800
+
1801
+ #define __pyx_mstate(o) ((__pyx_mstate *)__Pyx_PyModule_GetState(o))
1802
+
1803
+ #define __pyx_mstate_global (__pyx_mstate(PyState_FindModule(&__pyx_moduledef)))
1804
+
1805
+ #define __pyx_m (PyState_FindModule(&__pyx_moduledef))
1806
+ #else
1807
+ static __pyx_mstate __pyx_mstate_global_static =
1808
+ #ifdef __cplusplus
1809
+ {};
1810
+ #else
1811
+ {0};
1812
+ #endif
1813
+ static __pyx_mstate *__pyx_mstate_global = &__pyx_mstate_global_static;
1814
+ #endif
1815
+ /* #### Code section: module_state_clear ### */
1816
+ #if CYTHON_USE_MODULE_STATE
1817
+ static int __pyx_m_clear(PyObject *m) {
1818
+ __pyx_mstate *clear_module_state = __pyx_mstate(m);
1819
+ if (!clear_module_state) return 0;
1820
+ Py_CLEAR(clear_module_state->__pyx_d);
1821
+ Py_CLEAR(clear_module_state->__pyx_b);
1822
+ Py_CLEAR(clear_module_state->__pyx_cython_runtime);
1823
+ Py_CLEAR(clear_module_state->__pyx_empty_tuple);
1824
+ Py_CLEAR(clear_module_state->__pyx_empty_bytes);
1825
+ Py_CLEAR(clear_module_state->__pyx_empty_unicode);
1826
+ #ifdef __Pyx_CyFunction_USED
1827
+ Py_CLEAR(clear_module_state->__pyx_CyFunctionType);
1828
+ #endif
1829
+ #ifdef __Pyx_FusedFunction_USED
1830
+ Py_CLEAR(clear_module_state->__pyx_FusedFunctionType);
1831
+ #endif
1832
+ Py_CLEAR(clear_module_state->__pyx_n_s_);
1833
+ Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback);
1834
+ Py_CLEAR(clear_module_state->__pyx_n_s_main);
1835
+ Py_CLEAR(clear_module_state->__pyx_n_s_name);
1836
+ Py_CLEAR(clear_module_state->__pyx_n_s_test);
1837
+ return 0;
1838
+ }
1839
+ #endif
1840
+ /* #### Code section: module_state_traverse ### */
1841
+ #if CYTHON_USE_MODULE_STATE
1842
+ static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) {
1843
+ __pyx_mstate *traverse_module_state = __pyx_mstate(m);
1844
+ if (!traverse_module_state) return 0;
1845
+ Py_VISIT(traverse_module_state->__pyx_d);
1846
+ Py_VISIT(traverse_module_state->__pyx_b);
1847
+ Py_VISIT(traverse_module_state->__pyx_cython_runtime);
1848
+ Py_VISIT(traverse_module_state->__pyx_empty_tuple);
1849
+ Py_VISIT(traverse_module_state->__pyx_empty_bytes);
1850
+ Py_VISIT(traverse_module_state->__pyx_empty_unicode);
1851
+ #ifdef __Pyx_CyFunction_USED
1852
+ Py_VISIT(traverse_module_state->__pyx_CyFunctionType);
1853
+ #endif
1854
+ #ifdef __Pyx_FusedFunction_USED
1855
+ Py_VISIT(traverse_module_state->__pyx_FusedFunctionType);
1856
+ #endif
1857
+ Py_VISIT(traverse_module_state->__pyx_n_s_);
1858
+ Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback);
1859
+ Py_VISIT(traverse_module_state->__pyx_n_s_main);
1860
+ Py_VISIT(traverse_module_state->__pyx_n_s_name);
1861
+ Py_VISIT(traverse_module_state->__pyx_n_s_test);
1862
+ return 0;
1863
+ }
1864
+ #endif
1865
+ /* #### Code section: module_state_defines ### */
1866
+ #define __pyx_d __pyx_mstate_global->__pyx_d
1867
+ #define __pyx_b __pyx_mstate_global->__pyx_b
1868
+ #define __pyx_cython_runtime __pyx_mstate_global->__pyx_cython_runtime
1869
+ #define __pyx_empty_tuple __pyx_mstate_global->__pyx_empty_tuple
1870
+ #define __pyx_empty_bytes __pyx_mstate_global->__pyx_empty_bytes
1871
+ #define __pyx_empty_unicode __pyx_mstate_global->__pyx_empty_unicode
1872
+ #ifdef __Pyx_CyFunction_USED
1873
+ #define __pyx_CyFunctionType __pyx_mstate_global->__pyx_CyFunctionType
1874
+ #endif
1875
+ #ifdef __Pyx_FusedFunction_USED
1876
+ #define __pyx_FusedFunctionType __pyx_mstate_global->__pyx_FusedFunctionType
1877
+ #endif
1878
+ #ifdef __Pyx_Generator_USED
1879
+ #define __pyx_GeneratorType __pyx_mstate_global->__pyx_GeneratorType
1880
+ #endif
1881
+ #ifdef __Pyx_IterableCoroutine_USED
1882
+ #define __pyx_IterableCoroutineType __pyx_mstate_global->__pyx_IterableCoroutineType
1883
+ #endif
1884
+ #ifdef __Pyx_Coroutine_USED
1885
+ #define __pyx_CoroutineAwaitType __pyx_mstate_global->__pyx_CoroutineAwaitType
1886
+ #endif
1887
+ #ifdef __Pyx_Coroutine_USED
1888
+ #define __pyx_CoroutineType __pyx_mstate_global->__pyx_CoroutineType
1889
+ #endif
1890
+ #if CYTHON_USE_MODULE_STATE
1891
+ #endif
1892
+ #define __pyx_n_s_ __pyx_mstate_global->__pyx_n_s_
1893
+ #define __pyx_n_s_cline_in_traceback __pyx_mstate_global->__pyx_n_s_cline_in_traceback
1894
+ #define __pyx_n_s_main __pyx_mstate_global->__pyx_n_s_main
1895
+ #define __pyx_n_s_name __pyx_mstate_global->__pyx_n_s_name
1896
+ #define __pyx_n_s_test __pyx_mstate_global->__pyx_n_s_test
1897
+ /* #### Code section: module_code ### */
1898
+
1899
+ static PyMethodDef __pyx_methods[] = {
1900
+ {0, 0, 0, 0}
1901
+ };
1902
+ #ifndef CYTHON_SMALL_CODE
1903
+ #if defined(__clang__)
1904
+ #define CYTHON_SMALL_CODE
1905
+ #elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
1906
+ #define CYTHON_SMALL_CODE __attribute__((cold))
1907
+ #else
1908
+ #define CYTHON_SMALL_CODE
1909
+ #endif
1910
+ #endif
1911
+ /* #### Code section: pystring_table ### */
1912
+
1913
+ static int __Pyx_CreateStringTabAndInitStrings(void) {
1914
+ __Pyx_StringTabEntry __pyx_string_tab[] = {
1915
+ {&__pyx_n_s_, __pyx_k_, sizeof(__pyx_k_), 0, 0, 1, 1},
1916
+ {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1},
1917
+ {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},
1918
+ {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1},
1919
+ {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
1920
+ {0, 0, 0, 0, 0, 0, 0}
1921
+ };
1922
+ return __Pyx_InitStrings(__pyx_string_tab);
1923
+ }
1924
+ /* #### Code section: cached_builtins ### */
1925
+ static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) {
1926
+ return 0;
1927
+ }
1928
+ /* #### Code section: cached_constants ### */
1929
+
1930
+ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
1931
+ __Pyx_RefNannyDeclarations
1932
+ __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0);
1933
+ __Pyx_RefNannyFinishContext();
1934
+ return 0;
1935
+ }
1936
+ /* #### Code section: init_constants ### */
1937
+
1938
+ static CYTHON_SMALL_CODE int __Pyx_InitConstants(void) {
1939
+ if (__Pyx_CreateStringTabAndInitStrings() < 0) __PYX_ERR(0, 1, __pyx_L1_error);
1940
+ return 0;
1941
+ __pyx_L1_error:;
1942
+ return -1;
1943
+ }
1944
+ /* #### Code section: init_globals ### */
1945
+
1946
+ static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) {
1947
+ return 0;
1948
+ }
1949
+ /* #### Code section: init_module ### */
1950
+
1951
+ static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/
1952
+ static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/
1953
+ static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/
1954
+ static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/
1955
+ static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/
1956
+ static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/
1957
+ static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/
1958
+
1959
+ static int __Pyx_modinit_global_init_code(void) {
1960
+ __Pyx_RefNannyDeclarations
1961
+ __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0);
1962
+ /*--- Global init code ---*/
1963
+ __Pyx_RefNannyFinishContext();
1964
+ return 0;
1965
+ }
1966
+
1967
+ static int __Pyx_modinit_variable_export_code(void) {
1968
+ __Pyx_RefNannyDeclarations
1969
+ __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0);
1970
+ /*--- Variable export code ---*/
1971
+ __Pyx_RefNannyFinishContext();
1972
+ return 0;
1973
+ }
1974
+
1975
+ static int __Pyx_modinit_function_export_code(void) {
1976
+ __Pyx_RefNannyDeclarations
1977
+ __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0);
1978
+ /*--- Function export code ---*/
1979
+ __Pyx_RefNannyFinishContext();
1980
+ return 0;
1981
+ }
1982
+
1983
+ static int __Pyx_modinit_type_init_code(void) {
1984
+ __Pyx_RefNannyDeclarations
1985
+ __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0);
1986
+ /*--- Type init code ---*/
1987
+ __Pyx_RefNannyFinishContext();
1988
+ return 0;
1989
+ }
1990
+
1991
+ static int __Pyx_modinit_type_import_code(void) {
1992
+ __Pyx_RefNannyDeclarations
1993
+ __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0);
1994
+ /*--- Type import code ---*/
1995
+ __Pyx_RefNannyFinishContext();
1996
+ return 0;
1997
+ }
1998
+
1999
+ static int __Pyx_modinit_variable_import_code(void) {
2000
+ __Pyx_RefNannyDeclarations
2001
+ __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0);
2002
+ /*--- Variable import code ---*/
2003
+ __Pyx_RefNannyFinishContext();
2004
+ return 0;
2005
+ }
2006
+
2007
+ static int __Pyx_modinit_function_import_code(void) {
2008
+ __Pyx_RefNannyDeclarations
2009
+ __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0);
2010
+ /*--- Function import code ---*/
2011
+ __Pyx_RefNannyFinishContext();
2012
+ return 0;
2013
+ }
2014
+
2015
+
2016
+ #if PY_MAJOR_VERSION >= 3
2017
+ #if CYTHON_PEP489_MULTI_PHASE_INIT
2018
+ static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/
2019
+ static int __pyx_pymod_exec__dummy_holder(PyObject* module); /*proto*/
2020
+ static PyModuleDef_Slot __pyx_moduledef_slots[] = {
2021
+ {Py_mod_create, (void*)__pyx_pymod_create},
2022
+ {Py_mod_exec, (void*)__pyx_pymod_exec__dummy_holder},
2023
+ {0, NULL}
2024
+ };
2025
+ #endif
2026
+
2027
+ #ifdef __cplusplus
2028
+ namespace {
2029
+ struct PyModuleDef __pyx_moduledef =
2030
+ #else
2031
+ static struct PyModuleDef __pyx_moduledef =
2032
+ #endif
2033
+ {
2034
+ PyModuleDef_HEAD_INIT,
2035
+ "_dummy_holder",
2036
+ 0, /* m_doc */
2037
+ #if CYTHON_PEP489_MULTI_PHASE_INIT
2038
+ 0, /* m_size */
2039
+ #elif CYTHON_USE_MODULE_STATE
2040
+ sizeof(__pyx_mstate), /* m_size */
2041
+ #else
2042
+ -1, /* m_size */
2043
+ #endif
2044
+ __pyx_methods /* m_methods */,
2045
+ #if CYTHON_PEP489_MULTI_PHASE_INIT
2046
+ __pyx_moduledef_slots, /* m_slots */
2047
+ #else
2048
+ NULL, /* m_reload */
2049
+ #endif
2050
+ #if CYTHON_USE_MODULE_STATE
2051
+ __pyx_m_traverse, /* m_traverse */
2052
+ __pyx_m_clear, /* m_clear */
2053
+ NULL /* m_free */
2054
+ #else
2055
+ NULL, /* m_traverse */
2056
+ NULL, /* m_clear */
2057
+ NULL /* m_free */
2058
+ #endif
2059
+ };
2060
+ #ifdef __cplusplus
2061
+ } /* anonymous namespace */
2062
+ #endif
2063
+ #endif
2064
+
2065
+ #ifndef CYTHON_NO_PYINIT_EXPORT
2066
+ #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC
2067
+ #elif PY_MAJOR_VERSION < 3
2068
+ #ifdef __cplusplus
2069
+ #define __Pyx_PyMODINIT_FUNC extern "C" void
2070
+ #else
2071
+ #define __Pyx_PyMODINIT_FUNC void
2072
+ #endif
2073
+ #else
2074
+ #ifdef __cplusplus
2075
+ #define __Pyx_PyMODINIT_FUNC extern "C" PyObject *
2076
+ #else
2077
+ #define __Pyx_PyMODINIT_FUNC PyObject *
2078
+ #endif
2079
+ #endif
2080
+
2081
+
2082
+ #if PY_MAJOR_VERSION < 3
2083
+ __Pyx_PyMODINIT_FUNC init_dummy_holder(void) CYTHON_SMALL_CODE; /*proto*/
2084
+ __Pyx_PyMODINIT_FUNC init_dummy_holder(void)
2085
+ #else
2086
+ __Pyx_PyMODINIT_FUNC PyInit__dummy_holder(void) CYTHON_SMALL_CODE; /*proto*/
2087
+ __Pyx_PyMODINIT_FUNC PyInit__dummy_holder(void)
2088
+ #if CYTHON_PEP489_MULTI_PHASE_INIT
2089
+ {
2090
+ return PyModuleDef_Init(&__pyx_moduledef);
2091
+ }
2092
+ static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) {
2093
+ #if PY_VERSION_HEX >= 0x030700A1
2094
+ static PY_INT64_T main_interpreter_id = -1;
2095
+ PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp);
2096
+ if (main_interpreter_id == -1) {
2097
+ main_interpreter_id = current_id;
2098
+ return (unlikely(current_id == -1)) ? -1 : 0;
2099
+ } else if (unlikely(main_interpreter_id != current_id))
2100
+ #else
2101
+ static PyInterpreterState *main_interpreter = NULL;
2102
+ PyInterpreterState *current_interpreter = PyThreadState_Get()->interp;
2103
+ if (!main_interpreter) {
2104
+ main_interpreter = current_interpreter;
2105
+ } else if (unlikely(main_interpreter != current_interpreter))
2106
+ #endif
2107
+ {
2108
+ PyErr_SetString(
2109
+ PyExc_ImportError,
2110
+ "Interpreter change detected - this module can only be loaded into one interpreter per process.");
2111
+ return -1;
2112
+ }
2113
+ return 0;
2114
+ }
2115
+ #if CYTHON_COMPILING_IN_LIMITED_API
2116
+ static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *module, const char* from_name, const char* to_name, int allow_none)
2117
+ #else
2118
+ static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none)
2119
+ #endif
2120
+ {
2121
+ PyObject *value = PyObject_GetAttrString(spec, from_name);
2122
+ int result = 0;
2123
+ if (likely(value)) {
2124
+ if (allow_none || value != Py_None) {
2125
+ #if CYTHON_COMPILING_IN_LIMITED_API
2126
+ result = PyModule_AddObject(module, to_name, value);
2127
+ #else
2128
+ result = PyDict_SetItemString(moddict, to_name, value);
2129
+ #endif
2130
+ }
2131
+ Py_DECREF(value);
2132
+ } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
2133
+ PyErr_Clear();
2134
+ } else {
2135
+ result = -1;
2136
+ }
2137
+ return result;
2138
+ }
2139
+ static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def) {
2140
+ PyObject *module = NULL, *moddict, *modname;
2141
+ CYTHON_UNUSED_VAR(def);
2142
+ if (__Pyx_check_single_interpreter())
2143
+ return NULL;
2144
+ if (__pyx_m)
2145
+ return __Pyx_NewRef(__pyx_m);
2146
+ modname = PyObject_GetAttrString(spec, "name");
2147
+ if (unlikely(!modname)) goto bad;
2148
+ module = PyModule_NewObject(modname);
2149
+ Py_DECREF(modname);
2150
+ if (unlikely(!module)) goto bad;
2151
+ #if CYTHON_COMPILING_IN_LIMITED_API
2152
+ moddict = module;
2153
+ #else
2154
+ moddict = PyModule_GetDict(module);
2155
+ if (unlikely(!moddict)) goto bad;
2156
+ #endif
2157
+ if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad;
2158
+ if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad;
2159
+ if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad;
2160
+ if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad;
2161
+ return module;
2162
+ bad:
2163
+ Py_XDECREF(module);
2164
+ return NULL;
2165
+ }
2166
+
2167
+
2168
+ static CYTHON_SMALL_CODE int __pyx_pymod_exec__dummy_holder(PyObject *__pyx_pyinit_module)
2169
+ #endif
2170
+ #endif
2171
+ {
2172
+ int stringtab_initialized = 0;
2173
+ #if CYTHON_USE_MODULE_STATE
2174
+ int pystate_addmodule_run = 0;
2175
+ #endif
2176
+ PyObject *__pyx_t_1 = NULL;
2177
+ PyObject *__pyx_t_2 = NULL;
2178
+ int __pyx_lineno = 0;
2179
+ const char *__pyx_filename = NULL;
2180
+ int __pyx_clineno = 0;
2181
+ __Pyx_RefNannyDeclarations
2182
+ #if CYTHON_PEP489_MULTI_PHASE_INIT
2183
+ if (__pyx_m) {
2184
+ if (__pyx_m == __pyx_pyinit_module) return 0;
2185
+ PyErr_SetString(PyExc_RuntimeError, "Module '_dummy_holder' has already been imported. Re-initialisation is not supported.");
2186
+ return -1;
2187
+ }
2188
+ #elif PY_MAJOR_VERSION >= 3
2189
+ if (__pyx_m) return __Pyx_NewRef(__pyx_m);
2190
+ #endif
2191
+ /*--- Module creation code ---*/
2192
+ #if CYTHON_PEP489_MULTI_PHASE_INIT
2193
+ __pyx_m = __pyx_pyinit_module;
2194
+ Py_INCREF(__pyx_m);
2195
+ #else
2196
+ #if PY_MAJOR_VERSION < 3
2197
+ __pyx_m = Py_InitModule4("_dummy_holder", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);
2198
+ if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error)
2199
+ #elif CYTHON_USE_MODULE_STATE
2200
+ __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error)
2201
+ {
2202
+ int add_module_result = PyState_AddModule(__pyx_t_1, &__pyx_moduledef);
2203
+ __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "_dummy_holder" pseudovariable */
2204
+ if (unlikely((add_module_result < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
2205
+ pystate_addmodule_run = 1;
2206
+ }
2207
+ #else
2208
+ __pyx_m = PyModule_Create(&__pyx_moduledef);
2209
+ if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error)
2210
+ #endif
2211
+ #endif
2212
+ CYTHON_UNUSED_VAR(__pyx_t_1);
2213
+ __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error)
2214
+ Py_INCREF(__pyx_d);
2215
+ __pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error)
2216
+ __pyx_cython_runtime = __Pyx_PyImport_AddModuleRef((const char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error)
2217
+ if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
2218
+ #if CYTHON_REFNANNY
2219
+ __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny");
2220
+ if (!__Pyx_RefNanny) {
2221
+ PyErr_Clear();
2222
+ __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny");
2223
+ if (!__Pyx_RefNanny)
2224
+ Py_FatalError("failed to import 'refnanny' module");
2225
+ }
2226
+ #endif
2227
+ __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit__dummy_holder(void)", 0);
2228
+ if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
2229
+ #ifdef __Pxy_PyFrame_Initialize_Offsets
2230
+ __Pxy_PyFrame_Initialize_Offsets();
2231
+ #endif
2232
+ __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error)
2233
+ __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error)
2234
+ __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error)
2235
+ #ifdef __Pyx_CyFunction_USED
2236
+ if (__pyx_CyFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
2237
+ #endif
2238
+ #ifdef __Pyx_FusedFunction_USED
2239
+ if (__pyx_FusedFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
2240
+ #endif
2241
+ #ifdef __Pyx_Coroutine_USED
2242
+ if (__pyx_Coroutine_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
2243
+ #endif
2244
+ #ifdef __Pyx_Generator_USED
2245
+ if (__pyx_Generator_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
2246
+ #endif
2247
+ #ifdef __Pyx_AsyncGen_USED
2248
+ if (__pyx_AsyncGen_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
2249
+ #endif
2250
+ #ifdef __Pyx_StopAsyncIteration_USED
2251
+ if (__pyx_StopAsyncIteration_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
2252
+ #endif
2253
+ /*--- Library function declarations ---*/
2254
+ /*--- Threads initialization code ---*/
2255
+ #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS
2256
+ PyEval_InitThreads();
2257
+ #endif
2258
+ /*--- Initialize various global constants etc. ---*/
2259
+ if (__Pyx_InitConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
2260
+ stringtab_initialized = 1;
2261
+ if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
2262
+ #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT)
2263
+ if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
2264
+ #endif
2265
+ if (__pyx_module_is_main_webview___dummy_holder) {
2266
+ if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
2267
+ }
2268
+ #if PY_MAJOR_VERSION >= 3
2269
+ {
2270
+ PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error)
2271
+ if (!PyDict_GetItemString(modules, "webview._dummy_holder")) {
2272
+ if (unlikely((PyDict_SetItemString(modules, "webview._dummy_holder", __pyx_m) < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
2273
+ }
2274
+ }
2275
+ #endif
2276
+ /*--- Builtin init code ---*/
2277
+ if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
2278
+ /*--- Constants init code ---*/
2279
+ if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
2280
+ /*--- Global type/function init code ---*/
2281
+ (void)__Pyx_modinit_global_init_code();
2282
+ (void)__Pyx_modinit_variable_export_code();
2283
+ (void)__Pyx_modinit_function_export_code();
2284
+ (void)__Pyx_modinit_type_init_code();
2285
+ (void)__Pyx_modinit_type_import_code();
2286
+ (void)__Pyx_modinit_variable_import_code();
2287
+ (void)__Pyx_modinit_function_import_code();
2288
+ /*--- Execution code ---*/
2289
+ #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED)
2290
+ if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
2291
+ #endif
2292
+
2293
+ /* "webview/_dummy_holder.pyx":1
2294
+ # <<<<<<<<<<<<<<
2295
+ */
2296
+ __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error)
2297
+ __Pyx_GOTREF(__pyx_t_2);
2298
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
2299
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
2300
+
2301
+ /*--- Wrapped vars code ---*/
2302
+
2303
+ goto __pyx_L0;
2304
+ __pyx_L1_error:;
2305
+ __Pyx_XDECREF(__pyx_t_2);
2306
+ if (__pyx_m) {
2307
+ if (__pyx_d && stringtab_initialized) {
2308
+ __Pyx_AddTraceback("init webview._dummy_holder", __pyx_clineno, __pyx_lineno, __pyx_filename);
2309
+ }
2310
+ #if !CYTHON_USE_MODULE_STATE
2311
+ Py_CLEAR(__pyx_m);
2312
+ #else
2313
+ Py_DECREF(__pyx_m);
2314
+ if (pystate_addmodule_run) {
2315
+ PyObject *tp, *value, *tb;
2316
+ PyErr_Fetch(&tp, &value, &tb);
2317
+ PyState_RemoveModule(&__pyx_moduledef);
2318
+ PyErr_Restore(tp, value, tb);
2319
+ }
2320
+ #endif
2321
+ } else if (!PyErr_Occurred()) {
2322
+ PyErr_SetString(PyExc_ImportError, "init webview._dummy_holder");
2323
+ }
2324
+ __pyx_L0:;
2325
+ __Pyx_RefNannyFinishContext();
2326
+ #if CYTHON_PEP489_MULTI_PHASE_INIT
2327
+ return (__pyx_m != NULL) ? 0 : -1;
2328
+ #elif PY_MAJOR_VERSION >= 3
2329
+ return __pyx_m;
2330
+ #else
2331
+ return;
2332
+ #endif
2333
+ }
2334
+ /* #### Code section: cleanup_globals ### */
2335
+ /* #### Code section: cleanup_module ### */
2336
+ /* #### Code section: main_method ### */
2337
+ /* #### Code section: utility_code_pragmas ### */
2338
+ #ifdef _MSC_VER
2339
+ #pragma warning( push )
2340
+ /* Warning 4127: conditional expression is constant
2341
+ * Cython uses constant conditional expressions to allow in inline functions to be optimized at
2342
+ * compile-time, so this warning is not useful
2343
+ */
2344
+ #pragma warning( disable : 4127 )
2345
+ #endif
2346
+
2347
+
2348
+
2349
+ /* #### Code section: utility_code_def ### */
2350
+
2351
+ /* --- Runtime support code --- */
2352
+ /* Refnanny */
2353
+ #if CYTHON_REFNANNY
2354
+ static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) {
2355
+ PyObject *m = NULL, *p = NULL;
2356
+ void *r = NULL;
2357
+ m = PyImport_ImportModule(modname);
2358
+ if (!m) goto end;
2359
+ p = PyObject_GetAttrString(m, "RefNannyAPI");
2360
+ if (!p) goto end;
2361
+ r = PyLong_AsVoidPtr(p);
2362
+ end:
2363
+ Py_XDECREF(p);
2364
+ Py_XDECREF(m);
2365
+ return (__Pyx_RefNannyAPIStruct *)r;
2366
+ }
2367
+ #endif
2368
+
2369
+ /* PyDictVersioning */
2370
+ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
2371
+ static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) {
2372
+ PyObject *dict = Py_TYPE(obj)->tp_dict;
2373
+ return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0;
2374
+ }
2375
+ static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) {
2376
+ PyObject **dictptr = NULL;
2377
+ Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset;
2378
+ if (offset) {
2379
+ #if CYTHON_COMPILING_IN_CPYTHON
2380
+ dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj);
2381
+ #else
2382
+ dictptr = _PyObject_GetDictPtr(obj);
2383
+ #endif
2384
+ }
2385
+ return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0;
2386
+ }
2387
+ static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) {
2388
+ PyObject *dict = Py_TYPE(obj)->tp_dict;
2389
+ if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict)))
2390
+ return 0;
2391
+ return obj_dict_version == __Pyx_get_object_dict_version(obj);
2392
+ }
2393
+ #endif
2394
+
2395
+ /* PyErrExceptionMatches */
2396
+ #if CYTHON_FAST_THREAD_STATE
2397
+ static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
2398
+ Py_ssize_t i, n;
2399
+ n = PyTuple_GET_SIZE(tuple);
2400
+ #if PY_MAJOR_VERSION >= 3
2401
+ for (i=0; i<n; i++) {
2402
+ if (exc_type == PyTuple_GET_ITEM(tuple, i)) return 1;
2403
+ }
2404
+ #endif
2405
+ for (i=0; i<n; i++) {
2406
+ if (__Pyx_PyErr_GivenExceptionMatches(exc_type, PyTuple_GET_ITEM(tuple, i))) return 1;
2407
+ }
2408
+ return 0;
2409
+ }
2410
+ static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) {
2411
+ int result;
2412
+ PyObject *exc_type;
2413
+ #if PY_VERSION_HEX >= 0x030C00A6
2414
+ PyObject *current_exception = tstate->current_exception;
2415
+ if (unlikely(!current_exception)) return 0;
2416
+ exc_type = (PyObject*) Py_TYPE(current_exception);
2417
+ if (exc_type == err) return 1;
2418
+ #else
2419
+ exc_type = tstate->curexc_type;
2420
+ if (exc_type == err) return 1;
2421
+ if (unlikely(!exc_type)) return 0;
2422
+ #endif
2423
+ #if CYTHON_AVOID_BORROWED_REFS
2424
+ Py_INCREF(exc_type);
2425
+ #endif
2426
+ if (unlikely(PyTuple_Check(err))) {
2427
+ result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err);
2428
+ } else {
2429
+ result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err);
2430
+ }
2431
+ #if CYTHON_AVOID_BORROWED_REFS
2432
+ Py_DECREF(exc_type);
2433
+ #endif
2434
+ return result;
2435
+ }
2436
+ #endif
2437
+
2438
+ /* PyErrFetchRestore */
2439
+ #if CYTHON_FAST_THREAD_STATE
2440
+ static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
2441
+ #if PY_VERSION_HEX >= 0x030C00A6
2442
+ PyObject *tmp_value;
2443
+ assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value)));
2444
+ if (value) {
2445
+ #if CYTHON_COMPILING_IN_CPYTHON
2446
+ if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb))
2447
+ #endif
2448
+ PyException_SetTraceback(value, tb);
2449
+ }
2450
+ tmp_value = tstate->current_exception;
2451
+ tstate->current_exception = value;
2452
+ Py_XDECREF(tmp_value);
2453
+ Py_XDECREF(type);
2454
+ Py_XDECREF(tb);
2455
+ #else
2456
+ PyObject *tmp_type, *tmp_value, *tmp_tb;
2457
+ tmp_type = tstate->curexc_type;
2458
+ tmp_value = tstate->curexc_value;
2459
+ tmp_tb = tstate->curexc_traceback;
2460
+ tstate->curexc_type = type;
2461
+ tstate->curexc_value = value;
2462
+ tstate->curexc_traceback = tb;
2463
+ Py_XDECREF(tmp_type);
2464
+ Py_XDECREF(tmp_value);
2465
+ Py_XDECREF(tmp_tb);
2466
+ #endif
2467
+ }
2468
+ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
2469
+ #if PY_VERSION_HEX >= 0x030C00A6
2470
+ PyObject* exc_value;
2471
+ exc_value = tstate->current_exception;
2472
+ tstate->current_exception = 0;
2473
+ *value = exc_value;
2474
+ *type = NULL;
2475
+ *tb = NULL;
2476
+ if (exc_value) {
2477
+ *type = (PyObject*) Py_TYPE(exc_value);
2478
+ Py_INCREF(*type);
2479
+ #if CYTHON_COMPILING_IN_CPYTHON
2480
+ *tb = ((PyBaseExceptionObject*) exc_value)->traceback;
2481
+ Py_XINCREF(*tb);
2482
+ #else
2483
+ *tb = PyException_GetTraceback(exc_value);
2484
+ #endif
2485
+ }
2486
+ #else
2487
+ *type = tstate->curexc_type;
2488
+ *value = tstate->curexc_value;
2489
+ *tb = tstate->curexc_traceback;
2490
+ tstate->curexc_type = 0;
2491
+ tstate->curexc_value = 0;
2492
+ tstate->curexc_traceback = 0;
2493
+ #endif
2494
+ }
2495
+ #endif
2496
+
2497
+ /* PyObjectGetAttrStr */
2498
+ #if CYTHON_USE_TYPE_SLOTS
2499
+ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {
2500
+ PyTypeObject* tp = Py_TYPE(obj);
2501
+ if (likely(tp->tp_getattro))
2502
+ return tp->tp_getattro(obj, attr_name);
2503
+ #if PY_MAJOR_VERSION < 3
2504
+ if (likely(tp->tp_getattr))
2505
+ return tp->tp_getattr(obj, PyString_AS_STRING(attr_name));
2506
+ #endif
2507
+ return PyObject_GetAttr(obj, attr_name);
2508
+ }
2509
+ #endif
2510
+
2511
+ /* PyObjectGetAttrStrNoError */
2512
+ #if __PYX_LIMITED_VERSION_HEX < 0x030d00A1
2513
+ static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) {
2514
+ __Pyx_PyThreadState_declare
2515
+ __Pyx_PyThreadState_assign
2516
+ if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError)))
2517
+ __Pyx_PyErr_Clear();
2518
+ }
2519
+ #endif
2520
+ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) {
2521
+ PyObject *result;
2522
+ #if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1
2523
+ (void) PyObject_GetOptionalAttr(obj, attr_name, &result);
2524
+ return result;
2525
+ #else
2526
+ #if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1
2527
+ PyTypeObject* tp = Py_TYPE(obj);
2528
+ if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) {
2529
+ return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1);
2530
+ }
2531
+ #endif
2532
+ result = __Pyx_PyObject_GetAttrStr(obj, attr_name);
2533
+ if (unlikely(!result)) {
2534
+ __Pyx_PyObject_GetAttrStr_ClearAttributeError();
2535
+ }
2536
+ return result;
2537
+ #endif
2538
+ }
2539
+
2540
+ /* CLineInTraceback */
2541
+ #ifndef CYTHON_CLINE_IN_TRACEBACK
2542
+ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) {
2543
+ PyObject *use_cline;
2544
+ PyObject *ptype, *pvalue, *ptraceback;
2545
+ #if CYTHON_COMPILING_IN_CPYTHON
2546
+ PyObject **cython_runtime_dict;
2547
+ #endif
2548
+ CYTHON_MAYBE_UNUSED_VAR(tstate);
2549
+ if (unlikely(!__pyx_cython_runtime)) {
2550
+ return c_line;
2551
+ }
2552
+ __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback);
2553
+ #if CYTHON_COMPILING_IN_CPYTHON
2554
+ cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime);
2555
+ if (likely(cython_runtime_dict)) {
2556
+ __PYX_PY_DICT_LOOKUP_IF_MODIFIED(
2557
+ use_cline, *cython_runtime_dict,
2558
+ __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback))
2559
+ } else
2560
+ #endif
2561
+ {
2562
+ PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStrNoError(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback);
2563
+ if (use_cline_obj) {
2564
+ use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True;
2565
+ Py_DECREF(use_cline_obj);
2566
+ } else {
2567
+ PyErr_Clear();
2568
+ use_cline = NULL;
2569
+ }
2570
+ }
2571
+ if (!use_cline) {
2572
+ c_line = 0;
2573
+ (void) PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False);
2574
+ }
2575
+ else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) {
2576
+ c_line = 0;
2577
+ }
2578
+ __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback);
2579
+ return c_line;
2580
+ }
2581
+ #endif
2582
+
2583
+ /* CodeObjectCache */
2584
+ #if !CYTHON_COMPILING_IN_LIMITED_API
2585
+ static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) {
2586
+ int start = 0, mid = 0, end = count - 1;
2587
+ if (end >= 0 && code_line > entries[end].code_line) {
2588
+ return count;
2589
+ }
2590
+ while (start < end) {
2591
+ mid = start + (end - start) / 2;
2592
+ if (code_line < entries[mid].code_line) {
2593
+ end = mid;
2594
+ } else if (code_line > entries[mid].code_line) {
2595
+ start = mid + 1;
2596
+ } else {
2597
+ return mid;
2598
+ }
2599
+ }
2600
+ if (code_line <= entries[mid].code_line) {
2601
+ return mid;
2602
+ } else {
2603
+ return mid + 1;
2604
+ }
2605
+ }
2606
+ static PyCodeObject *__pyx_find_code_object(int code_line) {
2607
+ PyCodeObject* code_object;
2608
+ int pos;
2609
+ if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) {
2610
+ return NULL;
2611
+ }
2612
+ pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line);
2613
+ if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) {
2614
+ return NULL;
2615
+ }
2616
+ code_object = __pyx_code_cache.entries[pos].code_object;
2617
+ Py_INCREF(code_object);
2618
+ return code_object;
2619
+ }
2620
+ static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) {
2621
+ int pos, i;
2622
+ __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries;
2623
+ if (unlikely(!code_line)) {
2624
+ return;
2625
+ }
2626
+ if (unlikely(!entries)) {
2627
+ entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry));
2628
+ if (likely(entries)) {
2629
+ __pyx_code_cache.entries = entries;
2630
+ __pyx_code_cache.max_count = 64;
2631
+ __pyx_code_cache.count = 1;
2632
+ entries[0].code_line = code_line;
2633
+ entries[0].code_object = code_object;
2634
+ Py_INCREF(code_object);
2635
+ }
2636
+ return;
2637
+ }
2638
+ pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line);
2639
+ if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) {
2640
+ PyCodeObject* tmp = entries[pos].code_object;
2641
+ entries[pos].code_object = code_object;
2642
+ Py_DECREF(tmp);
2643
+ return;
2644
+ }
2645
+ if (__pyx_code_cache.count == __pyx_code_cache.max_count) {
2646
+ int new_max = __pyx_code_cache.max_count + 64;
2647
+ entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc(
2648
+ __pyx_code_cache.entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry));
2649
+ if (unlikely(!entries)) {
2650
+ return;
2651
+ }
2652
+ __pyx_code_cache.entries = entries;
2653
+ __pyx_code_cache.max_count = new_max;
2654
+ }
2655
+ for (i=__pyx_code_cache.count; i>pos; i--) {
2656
+ entries[i] = entries[i-1];
2657
+ }
2658
+ entries[pos].code_line = code_line;
2659
+ entries[pos].code_object = code_object;
2660
+ __pyx_code_cache.count++;
2661
+ Py_INCREF(code_object);
2662
+ }
2663
+ #endif
2664
+
2665
+ /* AddTraceback */
2666
+ #include "compile.h"
2667
+ #include "frameobject.h"
2668
+ #include "traceback.h"
2669
+ #if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API
2670
+ #ifndef Py_BUILD_CORE
2671
+ #define Py_BUILD_CORE 1
2672
+ #endif
2673
+ #include "internal/pycore_frame.h"
2674
+ #endif
2675
+ #if CYTHON_COMPILING_IN_LIMITED_API
2676
+ static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict,
2677
+ PyObject *firstlineno, PyObject *name) {
2678
+ PyObject *replace = NULL;
2679
+ if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL;
2680
+ if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL;
2681
+ replace = PyObject_GetAttrString(code, "replace");
2682
+ if (likely(replace)) {
2683
+ PyObject *result;
2684
+ result = PyObject_Call(replace, __pyx_empty_tuple, scratch_dict);
2685
+ Py_DECREF(replace);
2686
+ return result;
2687
+ }
2688
+ PyErr_Clear();
2689
+ #if __PYX_LIMITED_VERSION_HEX < 0x030780000
2690
+ {
2691
+ PyObject *compiled = NULL, *result = NULL;
2692
+ if (unlikely(PyDict_SetItemString(scratch_dict, "code", code))) return NULL;
2693
+ if (unlikely(PyDict_SetItemString(scratch_dict, "type", (PyObject*)(&PyType_Type)))) return NULL;
2694
+ compiled = Py_CompileString(
2695
+ "out = type(code)(\n"
2696
+ " code.co_argcount, code.co_kwonlyargcount, code.co_nlocals, code.co_stacksize,\n"
2697
+ " code.co_flags, code.co_code, code.co_consts, code.co_names,\n"
2698
+ " code.co_varnames, code.co_filename, co_name, co_firstlineno,\n"
2699
+ " code.co_lnotab)\n", "<dummy>", Py_file_input);
2700
+ if (!compiled) return NULL;
2701
+ result = PyEval_EvalCode(compiled, scratch_dict, scratch_dict);
2702
+ Py_DECREF(compiled);
2703
+ if (!result) PyErr_Print();
2704
+ Py_DECREF(result);
2705
+ result = PyDict_GetItemString(scratch_dict, "out");
2706
+ if (result) Py_INCREF(result);
2707
+ return result;
2708
+ }
2709
+ #else
2710
+ return NULL;
2711
+ #endif
2712
+ }
2713
+ static void __Pyx_AddTraceback(const char *funcname, int c_line,
2714
+ int py_line, const char *filename) {
2715
+ PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL;
2716
+ PyObject *replace = NULL, *getframe = NULL, *frame = NULL;
2717
+ PyObject *exc_type, *exc_value, *exc_traceback;
2718
+ int success = 0;
2719
+ if (c_line) {
2720
+ (void) __pyx_cfilenm;
2721
+ (void) __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line);
2722
+ }
2723
+ PyErr_Fetch(&exc_type, &exc_value, &exc_traceback);
2724
+ code_object = Py_CompileString("_getframe()", filename, Py_eval_input);
2725
+ if (unlikely(!code_object)) goto bad;
2726
+ py_py_line = PyLong_FromLong(py_line);
2727
+ if (unlikely(!py_py_line)) goto bad;
2728
+ py_funcname = PyUnicode_FromString(funcname);
2729
+ if (unlikely(!py_funcname)) goto bad;
2730
+ dict = PyDict_New();
2731
+ if (unlikely(!dict)) goto bad;
2732
+ {
2733
+ PyObject *old_code_object = code_object;
2734
+ code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname);
2735
+ Py_DECREF(old_code_object);
2736
+ }
2737
+ if (unlikely(!code_object)) goto bad;
2738
+ getframe = PySys_GetObject("_getframe");
2739
+ if (unlikely(!getframe)) goto bad;
2740
+ if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad;
2741
+ frame = PyEval_EvalCode(code_object, dict, dict);
2742
+ if (unlikely(!frame) || frame == Py_None) goto bad;
2743
+ success = 1;
2744
+ bad:
2745
+ PyErr_Restore(exc_type, exc_value, exc_traceback);
2746
+ Py_XDECREF(code_object);
2747
+ Py_XDECREF(py_py_line);
2748
+ Py_XDECREF(py_funcname);
2749
+ Py_XDECREF(dict);
2750
+ Py_XDECREF(replace);
2751
+ if (success) {
2752
+ PyTraceBack_Here(
2753
+ (struct _frame*)frame);
2754
+ }
2755
+ Py_XDECREF(frame);
2756
+ }
2757
+ #else
2758
+ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
2759
+ const char *funcname, int c_line,
2760
+ int py_line, const char *filename) {
2761
+ PyCodeObject *py_code = NULL;
2762
+ PyObject *py_funcname = NULL;
2763
+ #if PY_MAJOR_VERSION < 3
2764
+ PyObject *py_srcfile = NULL;
2765
+ py_srcfile = PyString_FromString(filename);
2766
+ if (!py_srcfile) goto bad;
2767
+ #endif
2768
+ if (c_line) {
2769
+ #if PY_MAJOR_VERSION < 3
2770
+ py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line);
2771
+ if (!py_funcname) goto bad;
2772
+ #else
2773
+ py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line);
2774
+ if (!py_funcname) goto bad;
2775
+ funcname = PyUnicode_AsUTF8(py_funcname);
2776
+ if (!funcname) goto bad;
2777
+ #endif
2778
+ }
2779
+ else {
2780
+ #if PY_MAJOR_VERSION < 3
2781
+ py_funcname = PyString_FromString(funcname);
2782
+ if (!py_funcname) goto bad;
2783
+ #endif
2784
+ }
2785
+ #if PY_MAJOR_VERSION < 3
2786
+ py_code = __Pyx_PyCode_New(
2787
+ 0,
2788
+ 0,
2789
+ 0,
2790
+ 0,
2791
+ 0,
2792
+ 0,
2793
+ __pyx_empty_bytes, /*PyObject *code,*/
2794
+ __pyx_empty_tuple, /*PyObject *consts,*/
2795
+ __pyx_empty_tuple, /*PyObject *names,*/
2796
+ __pyx_empty_tuple, /*PyObject *varnames,*/
2797
+ __pyx_empty_tuple, /*PyObject *freevars,*/
2798
+ __pyx_empty_tuple, /*PyObject *cellvars,*/
2799
+ py_srcfile, /*PyObject *filename,*/
2800
+ py_funcname, /*PyObject *name,*/
2801
+ py_line,
2802
+ __pyx_empty_bytes /*PyObject *lnotab*/
2803
+ );
2804
+ Py_DECREF(py_srcfile);
2805
+ #else
2806
+ py_code = PyCode_NewEmpty(filename, funcname, py_line);
2807
+ #endif
2808
+ Py_XDECREF(py_funcname);
2809
+ return py_code;
2810
+ bad:
2811
+ Py_XDECREF(py_funcname);
2812
+ #if PY_MAJOR_VERSION < 3
2813
+ Py_XDECREF(py_srcfile);
2814
+ #endif
2815
+ return NULL;
2816
+ }
2817
+ static void __Pyx_AddTraceback(const char *funcname, int c_line,
2818
+ int py_line, const char *filename) {
2819
+ PyCodeObject *py_code = 0;
2820
+ PyFrameObject *py_frame = 0;
2821
+ PyThreadState *tstate = __Pyx_PyThreadState_Current;
2822
+ PyObject *ptype, *pvalue, *ptraceback;
2823
+ if (c_line) {
2824
+ c_line = __Pyx_CLineForTraceback(tstate, c_line);
2825
+ }
2826
+ py_code = __pyx_find_code_object(c_line ? -c_line : py_line);
2827
+ if (!py_code) {
2828
+ __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback);
2829
+ py_code = __Pyx_CreateCodeObjectForTraceback(
2830
+ funcname, c_line, py_line, filename);
2831
+ if (!py_code) {
2832
+ /* If the code object creation fails, then we should clear the
2833
+ fetched exception references and propagate the new exception */
2834
+ Py_XDECREF(ptype);
2835
+ Py_XDECREF(pvalue);
2836
+ Py_XDECREF(ptraceback);
2837
+ goto bad;
2838
+ }
2839
+ __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback);
2840
+ __pyx_insert_code_object(c_line ? -c_line : py_line, py_code);
2841
+ }
2842
+ py_frame = PyFrame_New(
2843
+ tstate, /*PyThreadState *tstate,*/
2844
+ py_code, /*PyCodeObject *code,*/
2845
+ __pyx_d, /*PyObject *globals,*/
2846
+ 0 /*PyObject *locals*/
2847
+ );
2848
+ if (!py_frame) goto bad;
2849
+ __Pyx_PyFrame_SetLineNumber(py_frame, py_line);
2850
+ PyTraceBack_Here(py_frame);
2851
+ bad:
2852
+ Py_XDECREF(py_code);
2853
+ Py_XDECREF(py_frame);
2854
+ }
2855
+ #endif
2856
+
2857
+ /* FormatTypeName */
2858
+ #if CYTHON_COMPILING_IN_LIMITED_API
2859
+ static __Pyx_TypeName
2860
+ __Pyx_PyType_GetName(PyTypeObject* tp)
2861
+ {
2862
+ PyObject *name = __Pyx_PyObject_GetAttrStr((PyObject *)tp,
2863
+ __pyx_n_s_name);
2864
+ if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) {
2865
+ PyErr_Clear();
2866
+ Py_XDECREF(name);
2867
+ name = __Pyx_NewRef(__pyx_n_s_);
2868
+ }
2869
+ return name;
2870
+ }
2871
+ #endif
2872
+
2873
+ /* CIntToPy */
2874
+ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
2875
+ #ifdef __Pyx_HAS_GCC_DIAGNOSTIC
2876
+ #pragma GCC diagnostic push
2877
+ #pragma GCC diagnostic ignored "-Wconversion"
2878
+ #endif
2879
+ const long neg_one = (long) -1, const_zero = (long) 0;
2880
+ #ifdef __Pyx_HAS_GCC_DIAGNOSTIC
2881
+ #pragma GCC diagnostic pop
2882
+ #endif
2883
+ const int is_unsigned = neg_one > const_zero;
2884
+ if (is_unsigned) {
2885
+ if (sizeof(long) < sizeof(long)) {
2886
+ return PyInt_FromLong((long) value);
2887
+ } else if (sizeof(long) <= sizeof(unsigned long)) {
2888
+ return PyLong_FromUnsignedLong((unsigned long) value);
2889
+ #ifdef HAVE_LONG_LONG
2890
+ } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) {
2891
+ return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
2892
+ #endif
2893
+ }
2894
+ } else {
2895
+ if (sizeof(long) <= sizeof(long)) {
2896
+ return PyInt_FromLong((long) value);
2897
+ #ifdef HAVE_LONG_LONG
2898
+ } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {
2899
+ return PyLong_FromLongLong((PY_LONG_LONG) value);
2900
+ #endif
2901
+ }
2902
+ }
2903
+ {
2904
+ unsigned char *bytes = (unsigned char *)&value;
2905
+ #if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
2906
+ if (is_unsigned) {
2907
+ return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
2908
+ } else {
2909
+ return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
2910
+ }
2911
+ #elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
2912
+ int one = 1; int little = (int)*(unsigned char *)&one;
2913
+ return _PyLong_FromByteArray(bytes, sizeof(long),
2914
+ little, !is_unsigned);
2915
+ #else
2916
+ int one = 1; int little = (int)*(unsigned char *)&one;
2917
+ PyObject *from_bytes, *result = NULL;
2918
+ PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
2919
+ from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
2920
+ if (!from_bytes) return NULL;
2921
+ py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long));
2922
+ if (!py_bytes) goto limited_bad;
2923
+ order_str = PyUnicode_FromString(little ? "little" : "big");
2924
+ if (!order_str) goto limited_bad;
2925
+ arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
2926
+ if (!arg_tuple) goto limited_bad;
2927
+ if (!is_unsigned) {
2928
+ kwds = PyDict_New();
2929
+ if (!kwds) goto limited_bad;
2930
+ if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
2931
+ }
2932
+ result = PyObject_Call(from_bytes, arg_tuple, kwds);
2933
+ limited_bad:
2934
+ Py_XDECREF(kwds);
2935
+ Py_XDECREF(arg_tuple);
2936
+ Py_XDECREF(order_str);
2937
+ Py_XDECREF(py_bytes);
2938
+ Py_XDECREF(from_bytes);
2939
+ return result;
2940
+ #endif
2941
+ }
2942
+ }
2943
+
2944
+ /* CIntFromPyVerify */
2945
+ #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\
2946
+ __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0)
2947
+ #define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\
2948
+ __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1)
2949
+ #define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\
2950
+ {\
2951
+ func_type value = func_value;\
2952
+ if (sizeof(target_type) < sizeof(func_type)) {\
2953
+ if (unlikely(value != (func_type) (target_type) value)) {\
2954
+ func_type zero = 0;\
2955
+ if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\
2956
+ return (target_type) -1;\
2957
+ if (is_unsigned && unlikely(value < zero))\
2958
+ goto raise_neg_overflow;\
2959
+ else\
2960
+ goto raise_overflow;\
2961
+ }\
2962
+ }\
2963
+ return (target_type) value;\
2964
+ }
2965
+
2966
+ /* CIntFromPy */
2967
+ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
2968
+ #ifdef __Pyx_HAS_GCC_DIAGNOSTIC
2969
+ #pragma GCC diagnostic push
2970
+ #pragma GCC diagnostic ignored "-Wconversion"
2971
+ #endif
2972
+ const long neg_one = (long) -1, const_zero = (long) 0;
2973
+ #ifdef __Pyx_HAS_GCC_DIAGNOSTIC
2974
+ #pragma GCC diagnostic pop
2975
+ #endif
2976
+ const int is_unsigned = neg_one > const_zero;
2977
+ #if PY_MAJOR_VERSION < 3
2978
+ if (likely(PyInt_Check(x))) {
2979
+ if ((sizeof(long) < sizeof(long))) {
2980
+ __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x))
2981
+ } else {
2982
+ long val = PyInt_AS_LONG(x);
2983
+ if (is_unsigned && unlikely(val < 0)) {
2984
+ goto raise_neg_overflow;
2985
+ }
2986
+ return (long) val;
2987
+ }
2988
+ }
2989
+ #endif
2990
+ if (unlikely(!PyLong_Check(x))) {
2991
+ long val;
2992
+ PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
2993
+ if (!tmp) return (long) -1;
2994
+ val = __Pyx_PyInt_As_long(tmp);
2995
+ Py_DECREF(tmp);
2996
+ return val;
2997
+ }
2998
+ if (is_unsigned) {
2999
+ #if CYTHON_USE_PYLONG_INTERNALS
3000
+ if (unlikely(__Pyx_PyLong_IsNeg(x))) {
3001
+ goto raise_neg_overflow;
3002
+ } else if (__Pyx_PyLong_IsCompact(x)) {
3003
+ __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
3004
+ } else {
3005
+ const digit* digits = __Pyx_PyLong_Digits(x);
3006
+ assert(__Pyx_PyLong_DigitCount(x) > 1);
3007
+ switch (__Pyx_PyLong_DigitCount(x)) {
3008
+ case 2:
3009
+ if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) {
3010
+ if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
3011
+ __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
3012
+ } else if ((8 * sizeof(long) >= 2 * PyLong_SHIFT)) {
3013
+ return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
3014
+ }
3015
+ }
3016
+ break;
3017
+ case 3:
3018
+ if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) {
3019
+ if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
3020
+ __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
3021
+ } else if ((8 * sizeof(long) >= 3 * PyLong_SHIFT)) {
3022
+ return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
3023
+ }
3024
+ }
3025
+ break;
3026
+ case 4:
3027
+ if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) {
3028
+ if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
3029
+ __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
3030
+ } else if ((8 * sizeof(long) >= 4 * PyLong_SHIFT)) {
3031
+ return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
3032
+ }
3033
+ }
3034
+ break;
3035
+ }
3036
+ }
3037
+ #endif
3038
+ #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
3039
+ if (unlikely(Py_SIZE(x) < 0)) {
3040
+ goto raise_neg_overflow;
3041
+ }
3042
+ #else
3043
+ {
3044
+ int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
3045
+ if (unlikely(result < 0))
3046
+ return (long) -1;
3047
+ if (unlikely(result == 1))
3048
+ goto raise_neg_overflow;
3049
+ }
3050
+ #endif
3051
+ if ((sizeof(long) <= sizeof(unsigned long))) {
3052
+ __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x))
3053
+ #ifdef HAVE_LONG_LONG
3054
+ } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) {
3055
+ __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
3056
+ #endif
3057
+ }
3058
+ } else {
3059
+ #if CYTHON_USE_PYLONG_INTERNALS
3060
+ if (__Pyx_PyLong_IsCompact(x)) {
3061
+ __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
3062
+ } else {
3063
+ const digit* digits = __Pyx_PyLong_Digits(x);
3064
+ assert(__Pyx_PyLong_DigitCount(x) > 1);
3065
+ switch (__Pyx_PyLong_SignedDigitCount(x)) {
3066
+ case -2:
3067
+ if ((8 * sizeof(long) - 1 > 1 * PyLong_SHIFT)) {
3068
+ if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
3069
+ __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
3070
+ } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
3071
+ return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
3072
+ }
3073
+ }
3074
+ break;
3075
+ case 2:
3076
+ if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) {
3077
+ if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
3078
+ __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
3079
+ } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
3080
+ return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
3081
+ }
3082
+ }
3083
+ break;
3084
+ case -3:
3085
+ if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
3086
+ if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
3087
+ __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
3088
+ } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
3089
+ return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
3090
+ }
3091
+ }
3092
+ break;
3093
+ case 3:
3094
+ if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) {
3095
+ if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
3096
+ __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
3097
+ } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
3098
+ return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
3099
+ }
3100
+ }
3101
+ break;
3102
+ case -4:
3103
+ if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
3104
+ if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
3105
+ __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
3106
+ } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) {
3107
+ return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
3108
+ }
3109
+ }
3110
+ break;
3111
+ case 4:
3112
+ if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) {
3113
+ if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
3114
+ __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
3115
+ } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) {
3116
+ return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
3117
+ }
3118
+ }
3119
+ break;
3120
+ }
3121
+ }
3122
+ #endif
3123
+ if ((sizeof(long) <= sizeof(long))) {
3124
+ __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x))
3125
+ #ifdef HAVE_LONG_LONG
3126
+ } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) {
3127
+ __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x))
3128
+ #endif
3129
+ }
3130
+ }
3131
+ {
3132
+ long val;
3133
+ int ret = -1;
3134
+ #if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
3135
+ Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
3136
+ x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
3137
+ if (unlikely(bytes_copied == -1)) {
3138
+ } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
3139
+ goto raise_overflow;
3140
+ } else {
3141
+ ret = 0;
3142
+ }
3143
+ #elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
3144
+ int one = 1; int is_little = (int)*(unsigned char *)&one;
3145
+ unsigned char *bytes = (unsigned char *)&val;
3146
+ ret = _PyLong_AsByteArray((PyLongObject *)x,
3147
+ bytes, sizeof(val),
3148
+ is_little, !is_unsigned);
3149
+ #else
3150
+ PyObject *v;
3151
+ PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
3152
+ int bits, remaining_bits, is_negative = 0;
3153
+ int chunk_size = (sizeof(long) < 8) ? 30 : 62;
3154
+ if (likely(PyLong_CheckExact(x))) {
3155
+ v = __Pyx_NewRef(x);
3156
+ } else {
3157
+ v = PyNumber_Long(x);
3158
+ if (unlikely(!v)) return (long) -1;
3159
+ assert(PyLong_CheckExact(v));
3160
+ }
3161
+ {
3162
+ int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
3163
+ if (unlikely(result < 0)) {
3164
+ Py_DECREF(v);
3165
+ return (long) -1;
3166
+ }
3167
+ is_negative = result == 1;
3168
+ }
3169
+ if (is_unsigned && unlikely(is_negative)) {
3170
+ Py_DECREF(v);
3171
+ goto raise_neg_overflow;
3172
+ } else if (is_negative) {
3173
+ stepval = PyNumber_Invert(v);
3174
+ Py_DECREF(v);
3175
+ if (unlikely(!stepval))
3176
+ return (long) -1;
3177
+ } else {
3178
+ stepval = v;
3179
+ }
3180
+ v = NULL;
3181
+ val = (long) 0;
3182
+ mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
3183
+ shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
3184
+ for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) {
3185
+ PyObject *tmp, *digit;
3186
+ long idigit;
3187
+ digit = PyNumber_And(stepval, mask);
3188
+ if (unlikely(!digit)) goto done;
3189
+ idigit = PyLong_AsLong(digit);
3190
+ Py_DECREF(digit);
3191
+ if (unlikely(idigit < 0)) goto done;
3192
+ val |= ((long) idigit) << bits;
3193
+ tmp = PyNumber_Rshift(stepval, shift);
3194
+ if (unlikely(!tmp)) goto done;
3195
+ Py_DECREF(stepval); stepval = tmp;
3196
+ }
3197
+ Py_DECREF(shift); shift = NULL;
3198
+ Py_DECREF(mask); mask = NULL;
3199
+ {
3200
+ long idigit = PyLong_AsLong(stepval);
3201
+ if (unlikely(idigit < 0)) goto done;
3202
+ remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1);
3203
+ if (unlikely(idigit >= (1L << remaining_bits)))
3204
+ goto raise_overflow;
3205
+ val |= ((long) idigit) << bits;
3206
+ }
3207
+ if (!is_unsigned) {
3208
+ if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1))))
3209
+ goto raise_overflow;
3210
+ if (is_negative)
3211
+ val = ~val;
3212
+ }
3213
+ ret = 0;
3214
+ done:
3215
+ Py_XDECREF(shift);
3216
+ Py_XDECREF(mask);
3217
+ Py_XDECREF(stepval);
3218
+ #endif
3219
+ if (unlikely(ret))
3220
+ return (long) -1;
3221
+ return val;
3222
+ }
3223
+ raise_overflow:
3224
+ PyErr_SetString(PyExc_OverflowError,
3225
+ "value too large to convert to long");
3226
+ return (long) -1;
3227
+ raise_neg_overflow:
3228
+ PyErr_SetString(PyExc_OverflowError,
3229
+ "can't convert negative value to long");
3230
+ return (long) -1;
3231
+ }
3232
+
3233
+ /* CIntFromPy */
3234
+ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
3235
+ #ifdef __Pyx_HAS_GCC_DIAGNOSTIC
3236
+ #pragma GCC diagnostic push
3237
+ #pragma GCC diagnostic ignored "-Wconversion"
3238
+ #endif
3239
+ const int neg_one = (int) -1, const_zero = (int) 0;
3240
+ #ifdef __Pyx_HAS_GCC_DIAGNOSTIC
3241
+ #pragma GCC diagnostic pop
3242
+ #endif
3243
+ const int is_unsigned = neg_one > const_zero;
3244
+ #if PY_MAJOR_VERSION < 3
3245
+ if (likely(PyInt_Check(x))) {
3246
+ if ((sizeof(int) < sizeof(long))) {
3247
+ __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x))
3248
+ } else {
3249
+ long val = PyInt_AS_LONG(x);
3250
+ if (is_unsigned && unlikely(val < 0)) {
3251
+ goto raise_neg_overflow;
3252
+ }
3253
+ return (int) val;
3254
+ }
3255
+ }
3256
+ #endif
3257
+ if (unlikely(!PyLong_Check(x))) {
3258
+ int val;
3259
+ PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
3260
+ if (!tmp) return (int) -1;
3261
+ val = __Pyx_PyInt_As_int(tmp);
3262
+ Py_DECREF(tmp);
3263
+ return val;
3264
+ }
3265
+ if (is_unsigned) {
3266
+ #if CYTHON_USE_PYLONG_INTERNALS
3267
+ if (unlikely(__Pyx_PyLong_IsNeg(x))) {
3268
+ goto raise_neg_overflow;
3269
+ } else if (__Pyx_PyLong_IsCompact(x)) {
3270
+ __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
3271
+ } else {
3272
+ const digit* digits = __Pyx_PyLong_Digits(x);
3273
+ assert(__Pyx_PyLong_DigitCount(x) > 1);
3274
+ switch (__Pyx_PyLong_DigitCount(x)) {
3275
+ case 2:
3276
+ if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) {
3277
+ if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
3278
+ __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
3279
+ } else if ((8 * sizeof(int) >= 2 * PyLong_SHIFT)) {
3280
+ return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
3281
+ }
3282
+ }
3283
+ break;
3284
+ case 3:
3285
+ if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) {
3286
+ if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
3287
+ __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
3288
+ } else if ((8 * sizeof(int) >= 3 * PyLong_SHIFT)) {
3289
+ return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
3290
+ }
3291
+ }
3292
+ break;
3293
+ case 4:
3294
+ if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) {
3295
+ if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
3296
+ __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
3297
+ } else if ((8 * sizeof(int) >= 4 * PyLong_SHIFT)) {
3298
+ return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
3299
+ }
3300
+ }
3301
+ break;
3302
+ }
3303
+ }
3304
+ #endif
3305
+ #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
3306
+ if (unlikely(Py_SIZE(x) < 0)) {
3307
+ goto raise_neg_overflow;
3308
+ }
3309
+ #else
3310
+ {
3311
+ int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
3312
+ if (unlikely(result < 0))
3313
+ return (int) -1;
3314
+ if (unlikely(result == 1))
3315
+ goto raise_neg_overflow;
3316
+ }
3317
+ #endif
3318
+ if ((sizeof(int) <= sizeof(unsigned long))) {
3319
+ __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x))
3320
+ #ifdef HAVE_LONG_LONG
3321
+ } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) {
3322
+ __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
3323
+ #endif
3324
+ }
3325
+ } else {
3326
+ #if CYTHON_USE_PYLONG_INTERNALS
3327
+ if (__Pyx_PyLong_IsCompact(x)) {
3328
+ __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
3329
+ } else {
3330
+ const digit* digits = __Pyx_PyLong_Digits(x);
3331
+ assert(__Pyx_PyLong_DigitCount(x) > 1);
3332
+ switch (__Pyx_PyLong_SignedDigitCount(x)) {
3333
+ case -2:
3334
+ if ((8 * sizeof(int) - 1 > 1 * PyLong_SHIFT)) {
3335
+ if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
3336
+ __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
3337
+ } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
3338
+ return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
3339
+ }
3340
+ }
3341
+ break;
3342
+ case 2:
3343
+ if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) {
3344
+ if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
3345
+ __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
3346
+ } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
3347
+ return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
3348
+ }
3349
+ }
3350
+ break;
3351
+ case -3:
3352
+ if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
3353
+ if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
3354
+ __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
3355
+ } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
3356
+ return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
3357
+ }
3358
+ }
3359
+ break;
3360
+ case 3:
3361
+ if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) {
3362
+ if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
3363
+ __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
3364
+ } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
3365
+ return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
3366
+ }
3367
+ }
3368
+ break;
3369
+ case -4:
3370
+ if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
3371
+ if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
3372
+ __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
3373
+ } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) {
3374
+ return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
3375
+ }
3376
+ }
3377
+ break;
3378
+ case 4:
3379
+ if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) {
3380
+ if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
3381
+ __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
3382
+ } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) {
3383
+ return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
3384
+ }
3385
+ }
3386
+ break;
3387
+ }
3388
+ }
3389
+ #endif
3390
+ if ((sizeof(int) <= sizeof(long))) {
3391
+ __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x))
3392
+ #ifdef HAVE_LONG_LONG
3393
+ } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) {
3394
+ __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
3395
+ #endif
3396
+ }
3397
+ }
3398
+ {
3399
+ int val;
3400
+ int ret = -1;
3401
+ #if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
3402
+ Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
3403
+ x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
3404
+ if (unlikely(bytes_copied == -1)) {
3405
+ } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
3406
+ goto raise_overflow;
3407
+ } else {
3408
+ ret = 0;
3409
+ }
3410
+ #elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
3411
+ int one = 1; int is_little = (int)*(unsigned char *)&one;
3412
+ unsigned char *bytes = (unsigned char *)&val;
3413
+ ret = _PyLong_AsByteArray((PyLongObject *)x,
3414
+ bytes, sizeof(val),
3415
+ is_little, !is_unsigned);
3416
+ #else
3417
+ PyObject *v;
3418
+ PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
3419
+ int bits, remaining_bits, is_negative = 0;
3420
+ int chunk_size = (sizeof(long) < 8) ? 30 : 62;
3421
+ if (likely(PyLong_CheckExact(x))) {
3422
+ v = __Pyx_NewRef(x);
3423
+ } else {
3424
+ v = PyNumber_Long(x);
3425
+ if (unlikely(!v)) return (int) -1;
3426
+ assert(PyLong_CheckExact(v));
3427
+ }
3428
+ {
3429
+ int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
3430
+ if (unlikely(result < 0)) {
3431
+ Py_DECREF(v);
3432
+ return (int) -1;
3433
+ }
3434
+ is_negative = result == 1;
3435
+ }
3436
+ if (is_unsigned && unlikely(is_negative)) {
3437
+ Py_DECREF(v);
3438
+ goto raise_neg_overflow;
3439
+ } else if (is_negative) {
3440
+ stepval = PyNumber_Invert(v);
3441
+ Py_DECREF(v);
3442
+ if (unlikely(!stepval))
3443
+ return (int) -1;
3444
+ } else {
3445
+ stepval = v;
3446
+ }
3447
+ v = NULL;
3448
+ val = (int) 0;
3449
+ mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
3450
+ shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
3451
+ for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) {
3452
+ PyObject *tmp, *digit;
3453
+ long idigit;
3454
+ digit = PyNumber_And(stepval, mask);
3455
+ if (unlikely(!digit)) goto done;
3456
+ idigit = PyLong_AsLong(digit);
3457
+ Py_DECREF(digit);
3458
+ if (unlikely(idigit < 0)) goto done;
3459
+ val |= ((int) idigit) << bits;
3460
+ tmp = PyNumber_Rshift(stepval, shift);
3461
+ if (unlikely(!tmp)) goto done;
3462
+ Py_DECREF(stepval); stepval = tmp;
3463
+ }
3464
+ Py_DECREF(shift); shift = NULL;
3465
+ Py_DECREF(mask); mask = NULL;
3466
+ {
3467
+ long idigit = PyLong_AsLong(stepval);
3468
+ if (unlikely(idigit < 0)) goto done;
3469
+ remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1);
3470
+ if (unlikely(idigit >= (1L << remaining_bits)))
3471
+ goto raise_overflow;
3472
+ val |= ((int) idigit) << bits;
3473
+ }
3474
+ if (!is_unsigned) {
3475
+ if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1))))
3476
+ goto raise_overflow;
3477
+ if (is_negative)
3478
+ val = ~val;
3479
+ }
3480
+ ret = 0;
3481
+ done:
3482
+ Py_XDECREF(shift);
3483
+ Py_XDECREF(mask);
3484
+ Py_XDECREF(stepval);
3485
+ #endif
3486
+ if (unlikely(ret))
3487
+ return (int) -1;
3488
+ return val;
3489
+ }
3490
+ raise_overflow:
3491
+ PyErr_SetString(PyExc_OverflowError,
3492
+ "value too large to convert to int");
3493
+ return (int) -1;
3494
+ raise_neg_overflow:
3495
+ PyErr_SetString(PyExc_OverflowError,
3496
+ "can't convert negative value to int");
3497
+ return (int) -1;
3498
+ }
3499
+
3500
+ /* FastTypeChecks */
3501
+ #if CYTHON_COMPILING_IN_CPYTHON
3502
+ static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) {
3503
+ while (a) {
3504
+ a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*);
3505
+ if (a == b)
3506
+ return 1;
3507
+ }
3508
+ return b == &PyBaseObject_Type;
3509
+ }
3510
+ static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) {
3511
+ PyObject *mro;
3512
+ if (a == b) return 1;
3513
+ mro = a->tp_mro;
3514
+ if (likely(mro)) {
3515
+ Py_ssize_t i, n;
3516
+ n = PyTuple_GET_SIZE(mro);
3517
+ for (i = 0; i < n; i++) {
3518
+ if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b)
3519
+ return 1;
3520
+ }
3521
+ return 0;
3522
+ }
3523
+ return __Pyx_InBases(a, b);
3524
+ }
3525
+ static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b) {
3526
+ PyObject *mro;
3527
+ if (cls == a || cls == b) return 1;
3528
+ mro = cls->tp_mro;
3529
+ if (likely(mro)) {
3530
+ Py_ssize_t i, n;
3531
+ n = PyTuple_GET_SIZE(mro);
3532
+ for (i = 0; i < n; i++) {
3533
+ PyObject *base = PyTuple_GET_ITEM(mro, i);
3534
+ if (base == (PyObject *)a || base == (PyObject *)b)
3535
+ return 1;
3536
+ }
3537
+ return 0;
3538
+ }
3539
+ return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, b);
3540
+ }
3541
+ #if PY_MAJOR_VERSION == 2
3542
+ static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) {
3543
+ PyObject *exception, *value, *tb;
3544
+ int res;
3545
+ __Pyx_PyThreadState_declare
3546
+ __Pyx_PyThreadState_assign
3547
+ __Pyx_ErrFetch(&exception, &value, &tb);
3548
+ res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0;
3549
+ if (unlikely(res == -1)) {
3550
+ PyErr_WriteUnraisable(err);
3551
+ res = 0;
3552
+ }
3553
+ if (!res) {
3554
+ res = PyObject_IsSubclass(err, exc_type2);
3555
+ if (unlikely(res == -1)) {
3556
+ PyErr_WriteUnraisable(err);
3557
+ res = 0;
3558
+ }
3559
+ }
3560
+ __Pyx_ErrRestore(exception, value, tb);
3561
+ return res;
3562
+ }
3563
+ #else
3564
+ static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) {
3565
+ if (exc_type1) {
3566
+ return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2);
3567
+ } else {
3568
+ return __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2);
3569
+ }
3570
+ }
3571
+ #endif
3572
+ static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
3573
+ Py_ssize_t i, n;
3574
+ assert(PyExceptionClass_Check(exc_type));
3575
+ n = PyTuple_GET_SIZE(tuple);
3576
+ #if PY_MAJOR_VERSION >= 3
3577
+ for (i=0; i<n; i++) {
3578
+ if (exc_type == PyTuple_GET_ITEM(tuple, i)) return 1;
3579
+ }
3580
+ #endif
3581
+ for (i=0; i<n; i++) {
3582
+ PyObject *t = PyTuple_GET_ITEM(tuple, i);
3583
+ #if PY_MAJOR_VERSION < 3
3584
+ if (likely(exc_type == t)) return 1;
3585
+ #endif
3586
+ if (likely(PyExceptionClass_Check(t))) {
3587
+ if (__Pyx_inner_PyErr_GivenExceptionMatches2(exc_type, NULL, t)) return 1;
3588
+ } else {
3589
+ }
3590
+ }
3591
+ return 0;
3592
+ }
3593
+ static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject* exc_type) {
3594
+ if (likely(err == exc_type)) return 1;
3595
+ if (likely(PyExceptionClass_Check(err))) {
3596
+ if (likely(PyExceptionClass_Check(exc_type))) {
3597
+ return __Pyx_inner_PyErr_GivenExceptionMatches2(err, NULL, exc_type);
3598
+ } else if (likely(PyTuple_Check(exc_type))) {
3599
+ return __Pyx_PyErr_GivenExceptionMatchesTuple(err, exc_type);
3600
+ } else {
3601
+ }
3602
+ }
3603
+ return PyErr_GivenExceptionMatches(err, exc_type);
3604
+ }
3605
+ static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *exc_type1, PyObject *exc_type2) {
3606
+ assert(PyExceptionClass_Check(exc_type1));
3607
+ assert(PyExceptionClass_Check(exc_type2));
3608
+ if (likely(err == exc_type1 || err == exc_type2)) return 1;
3609
+ if (likely(PyExceptionClass_Check(err))) {
3610
+ return __Pyx_inner_PyErr_GivenExceptionMatches2(err, exc_type1, exc_type2);
3611
+ }
3612
+ return (PyErr_GivenExceptionMatches(err, exc_type1) || PyErr_GivenExceptionMatches(err, exc_type2));
3613
+ }
3614
+ #endif
3615
+
3616
+ /* CheckBinaryVersion */
3617
+ static unsigned long __Pyx_get_runtime_version(void) {
3618
+ #if __PYX_LIMITED_VERSION_HEX >= 0x030B00A4
3619
+ return Py_Version & ~0xFFUL;
3620
+ #else
3621
+ const char* rt_version = Py_GetVersion();
3622
+ unsigned long version = 0;
3623
+ unsigned long factor = 0x01000000UL;
3624
+ unsigned int digit = 0;
3625
+ int i = 0;
3626
+ while (factor) {
3627
+ while ('0' <= rt_version[i] && rt_version[i] <= '9') {
3628
+ digit = digit * 10 + (unsigned int) (rt_version[i] - '0');
3629
+ ++i;
3630
+ }
3631
+ version += factor * digit;
3632
+ if (rt_version[i] != '.')
3633
+ break;
3634
+ digit = 0;
3635
+ factor >>= 8;
3636
+ ++i;
3637
+ }
3638
+ return version;
3639
+ #endif
3640
+ }
3641
+ static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer) {
3642
+ const unsigned long MAJOR_MINOR = 0xFFFF0000UL;
3643
+ if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR))
3644
+ return 0;
3645
+ if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR)))
3646
+ return 1;
3647
+ {
3648
+ char message[200];
3649
+ PyOS_snprintf(message, sizeof(message),
3650
+ "compile time Python version %d.%d "
3651
+ "of module '%.100s' "
3652
+ "%s "
3653
+ "runtime version %d.%d",
3654
+ (int) (ct_version >> 24), (int) ((ct_version >> 16) & 0xFF),
3655
+ __Pyx_MODULE_NAME,
3656
+ (allow_newer) ? "was newer than" : "does not match",
3657
+ (int) (rt_version >> 24), (int) ((rt_version >> 16) & 0xFF)
3658
+ );
3659
+ return PyErr_WarnEx(NULL, message, 1);
3660
+ }
3661
+ }
3662
+
3663
+ /* InitStrings */
3664
+ #if PY_MAJOR_VERSION >= 3
3665
+ static int __Pyx_InitString(__Pyx_StringTabEntry t, PyObject **str) {
3666
+ if (t.is_unicode | t.is_str) {
3667
+ if (t.intern) {
3668
+ *str = PyUnicode_InternFromString(t.s);
3669
+ } else if (t.encoding) {
3670
+ *str = PyUnicode_Decode(t.s, t.n - 1, t.encoding, NULL);
3671
+ } else {
3672
+ *str = PyUnicode_FromStringAndSize(t.s, t.n - 1);
3673
+ }
3674
+ } else {
3675
+ *str = PyBytes_FromStringAndSize(t.s, t.n - 1);
3676
+ }
3677
+ if (!*str)
3678
+ return -1;
3679
+ if (PyObject_Hash(*str) == -1)
3680
+ return -1;
3681
+ return 0;
3682
+ }
3683
+ #endif
3684
+ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
3685
+ while (t->p) {
3686
+ #if PY_MAJOR_VERSION >= 3
3687
+ __Pyx_InitString(*t, t->p);
3688
+ #else
3689
+ if (t->is_unicode) {
3690
+ *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL);
3691
+ } else if (t->intern) {
3692
+ *t->p = PyString_InternFromString(t->s);
3693
+ } else {
3694
+ *t->p = PyString_FromStringAndSize(t->s, t->n - 1);
3695
+ }
3696
+ if (!*t->p)
3697
+ return -1;
3698
+ if (PyObject_Hash(*t->p) == -1)
3699
+ return -1;
3700
+ #endif
3701
+ ++t;
3702
+ }
3703
+ return 0;
3704
+ }
3705
+
3706
+ #include <string.h>
3707
+ static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) {
3708
+ size_t len = strlen(s);
3709
+ if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) {
3710
+ PyErr_SetString(PyExc_OverflowError, "byte string is too long");
3711
+ return -1;
3712
+ }
3713
+ return (Py_ssize_t) len;
3714
+ }
3715
+ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) {
3716
+ Py_ssize_t len = __Pyx_ssize_strlen(c_str);
3717
+ if (unlikely(len < 0)) return NULL;
3718
+ return __Pyx_PyUnicode_FromStringAndSize(c_str, len);
3719
+ }
3720
+ static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) {
3721
+ Py_ssize_t len = __Pyx_ssize_strlen(c_str);
3722
+ if (unlikely(len < 0)) return NULL;
3723
+ return PyByteArray_FromStringAndSize(c_str, len);
3724
+ }
3725
+ static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) {
3726
+ Py_ssize_t ignore;
3727
+ return __Pyx_PyObject_AsStringAndSize(o, &ignore);
3728
+ }
3729
+ #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
3730
+ #if !CYTHON_PEP393_ENABLED
3731
+ static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) {
3732
+ char* defenc_c;
3733
+ PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL);
3734
+ if (!defenc) return NULL;
3735
+ defenc_c = PyBytes_AS_STRING(defenc);
3736
+ #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
3737
+ {
3738
+ char* end = defenc_c + PyBytes_GET_SIZE(defenc);
3739
+ char* c;
3740
+ for (c = defenc_c; c < end; c++) {
3741
+ if ((unsigned char) (*c) >= 128) {
3742
+ PyUnicode_AsASCIIString(o);
3743
+ return NULL;
3744
+ }
3745
+ }
3746
+ }
3747
+ #endif
3748
+ *length = PyBytes_GET_SIZE(defenc);
3749
+ return defenc_c;
3750
+ }
3751
+ #else
3752
+ static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) {
3753
+ if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL;
3754
+ #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
3755
+ if (likely(PyUnicode_IS_ASCII(o))) {
3756
+ *length = PyUnicode_GET_LENGTH(o);
3757
+ return PyUnicode_AsUTF8(o);
3758
+ } else {
3759
+ PyUnicode_AsASCIIString(o);
3760
+ return NULL;
3761
+ }
3762
+ #else
3763
+ return PyUnicode_AsUTF8AndSize(o, length);
3764
+ #endif
3765
+ }
3766
+ #endif
3767
+ #endif
3768
+ static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) {
3769
+ #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
3770
+ if (
3771
+ #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
3772
+ __Pyx_sys_getdefaultencoding_not_ascii &&
3773
+ #endif
3774
+ PyUnicode_Check(o)) {
3775
+ return __Pyx_PyUnicode_AsStringAndSize(o, length);
3776
+ } else
3777
+ #endif
3778
+ #if (!CYTHON_COMPILING_IN_PYPY && !CYTHON_COMPILING_IN_LIMITED_API) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
3779
+ if (PyByteArray_Check(o)) {
3780
+ *length = PyByteArray_GET_SIZE(o);
3781
+ return PyByteArray_AS_STRING(o);
3782
+ } else
3783
+ #endif
3784
+ {
3785
+ char* result;
3786
+ int r = PyBytes_AsStringAndSize(o, &result, length);
3787
+ if (unlikely(r < 0)) {
3788
+ return NULL;
3789
+ } else {
3790
+ return result;
3791
+ }
3792
+ }
3793
+ }
3794
+ static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) {
3795
+ int is_true = x == Py_True;
3796
+ if (is_true | (x == Py_False) | (x == Py_None)) return is_true;
3797
+ else return PyObject_IsTrue(x);
3798
+ }
3799
+ static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) {
3800
+ int retval;
3801
+ if (unlikely(!x)) return -1;
3802
+ retval = __Pyx_PyObject_IsTrue(x);
3803
+ Py_DECREF(x);
3804
+ return retval;
3805
+ }
3806
+ static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) {
3807
+ __Pyx_TypeName result_type_name = __Pyx_PyType_GetName(Py_TYPE(result));
3808
+ #if PY_MAJOR_VERSION >= 3
3809
+ if (PyLong_Check(result)) {
3810
+ if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1,
3811
+ "__int__ returned non-int (type " __Pyx_FMT_TYPENAME "). "
3812
+ "The ability to return an instance of a strict subclass of int is deprecated, "
3813
+ "and may be removed in a future version of Python.",
3814
+ result_type_name)) {
3815
+ __Pyx_DECREF_TypeName(result_type_name);
3816
+ Py_DECREF(result);
3817
+ return NULL;
3818
+ }
3819
+ __Pyx_DECREF_TypeName(result_type_name);
3820
+ return result;
3821
+ }
3822
+ #endif
3823
+ PyErr_Format(PyExc_TypeError,
3824
+ "__%.4s__ returned non-%.4s (type " __Pyx_FMT_TYPENAME ")",
3825
+ type_name, type_name, result_type_name);
3826
+ __Pyx_DECREF_TypeName(result_type_name);
3827
+ Py_DECREF(result);
3828
+ return NULL;
3829
+ }
3830
+ static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) {
3831
+ #if CYTHON_USE_TYPE_SLOTS
3832
+ PyNumberMethods *m;
3833
+ #endif
3834
+ const char *name = NULL;
3835
+ PyObject *res = NULL;
3836
+ #if PY_MAJOR_VERSION < 3
3837
+ if (likely(PyInt_Check(x) || PyLong_Check(x)))
3838
+ #else
3839
+ if (likely(PyLong_Check(x)))
3840
+ #endif
3841
+ return __Pyx_NewRef(x);
3842
+ #if CYTHON_USE_TYPE_SLOTS
3843
+ m = Py_TYPE(x)->tp_as_number;
3844
+ #if PY_MAJOR_VERSION < 3
3845
+ if (m && m->nb_int) {
3846
+ name = "int";
3847
+ res = m->nb_int(x);
3848
+ }
3849
+ else if (m && m->nb_long) {
3850
+ name = "long";
3851
+ res = m->nb_long(x);
3852
+ }
3853
+ #else
3854
+ if (likely(m && m->nb_int)) {
3855
+ name = "int";
3856
+ res = m->nb_int(x);
3857
+ }
3858
+ #endif
3859
+ #else
3860
+ if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) {
3861
+ res = PyNumber_Int(x);
3862
+ }
3863
+ #endif
3864
+ if (likely(res)) {
3865
+ #if PY_MAJOR_VERSION < 3
3866
+ if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) {
3867
+ #else
3868
+ if (unlikely(!PyLong_CheckExact(res))) {
3869
+ #endif
3870
+ return __Pyx_PyNumber_IntOrLongWrongResultType(res, name);
3871
+ }
3872
+ }
3873
+ else if (!PyErr_Occurred()) {
3874
+ PyErr_SetString(PyExc_TypeError,
3875
+ "an integer is required");
3876
+ }
3877
+ return res;
3878
+ }
3879
+ static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) {
3880
+ Py_ssize_t ival;
3881
+ PyObject *x;
3882
+ #if PY_MAJOR_VERSION < 3
3883
+ if (likely(PyInt_CheckExact(b))) {
3884
+ if (sizeof(Py_ssize_t) >= sizeof(long))
3885
+ return PyInt_AS_LONG(b);
3886
+ else
3887
+ return PyInt_AsSsize_t(b);
3888
+ }
3889
+ #endif
3890
+ if (likely(PyLong_CheckExact(b))) {
3891
+ #if CYTHON_USE_PYLONG_INTERNALS
3892
+ if (likely(__Pyx_PyLong_IsCompact(b))) {
3893
+ return __Pyx_PyLong_CompactValue(b);
3894
+ } else {
3895
+ const digit* digits = __Pyx_PyLong_Digits(b);
3896
+ const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b);
3897
+ switch (size) {
3898
+ case 2:
3899
+ if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
3900
+ return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
3901
+ }
3902
+ break;
3903
+ case -2:
3904
+ if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
3905
+ return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
3906
+ }
3907
+ break;
3908
+ case 3:
3909
+ if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) {
3910
+ return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
3911
+ }
3912
+ break;
3913
+ case -3:
3914
+ if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) {
3915
+ return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
3916
+ }
3917
+ break;
3918
+ case 4:
3919
+ if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) {
3920
+ return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
3921
+ }
3922
+ break;
3923
+ case -4:
3924
+ if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) {
3925
+ return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
3926
+ }
3927
+ break;
3928
+ }
3929
+ }
3930
+ #endif
3931
+ return PyLong_AsSsize_t(b);
3932
+ }
3933
+ x = PyNumber_Index(b);
3934
+ if (!x) return -1;
3935
+ ival = PyInt_AsSsize_t(x);
3936
+ Py_DECREF(x);
3937
+ return ival;
3938
+ }
3939
+ static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject* o) {
3940
+ if (sizeof(Py_hash_t) == sizeof(Py_ssize_t)) {
3941
+ return (Py_hash_t) __Pyx_PyIndex_AsSsize_t(o);
3942
+ #if PY_MAJOR_VERSION < 3
3943
+ } else if (likely(PyInt_CheckExact(o))) {
3944
+ return PyInt_AS_LONG(o);
3945
+ #endif
3946
+ } else {
3947
+ Py_ssize_t ival;
3948
+ PyObject *x;
3949
+ x = PyNumber_Index(o);
3950
+ if (!x) return -1;
3951
+ ival = PyInt_AsLong(x);
3952
+ Py_DECREF(x);
3953
+ return ival;
3954
+ }
3955
+ }
3956
+ static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) {
3957
+ return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False);
3958
+ }
3959
+ static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) {
3960
+ return PyInt_FromSize_t(ival);
3961
+ }
3962
+
3963
+
3964
+ /* #### Code section: utility_code_pragmas_end ### */
3965
+ #ifdef _MSC_VER
3966
+ #pragma warning( pop )
3967
+ #endif
3968
+
3969
+
3970
+
3971
+ /* #### Code section: end ### */
3972
+ #endif /* Py_PYTHON_H */