1 /*[clinic input]
2 preserve
3 [clinic start generated code]*/
4
5 #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
6 # include "pycore_gc.h" // PyGC_Head
7 # include "pycore_runtime.h" // _Py_ID()
8 #endif
9
10
11 PyDoc_STRVAR(_operator_truth__doc__,
12 "truth($module, a, /)\n"
13 "--\n"
14 "\n"
15 "Return True if a is true, False otherwise.");
16
17 #define _OPERATOR_TRUTH_METHODDEF \
18 {"truth", (PyCFunction)_operator_truth, METH_O, _operator_truth__doc__},
19
20 static int
21 _operator_truth_impl(PyObject *module, PyObject *a);
22
23 static PyObject *
24 _operator_truth(PyObject *module, PyObject *a)
25 {
26 PyObject *return_value = NULL;
27 int _return_value;
28
29 _return_value = _operator_truth_impl(module, a);
30 if ((_return_value == -1) && PyErr_Occurred()) {
31 goto exit;
32 }
33 return_value = PyBool_FromLong((long)_return_value);
34
35 exit:
36 return return_value;
37 }
38
39 PyDoc_STRVAR(_operator_add__doc__,
40 "add($module, a, b, /)\n"
41 "--\n"
42 "\n"
43 "Same as a + b.");
44
45 #define _OPERATOR_ADD_METHODDEF \
46 {"add", _PyCFunction_CAST(_operator_add), METH_FASTCALL, _operator_add__doc__},
47
48 static PyObject *
49 _operator_add_impl(PyObject *module, PyObject *a, PyObject *b);
50
51 static PyObject *
52 _operator_add(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
53 {
54 PyObject *return_value = NULL;
55 PyObject *a;
56 PyObject *b;
57
58 if (!_PyArg_CheckPositional("add", nargs, 2, 2)) {
59 goto exit;
60 }
61 a = args[0];
62 b = args[1];
63 return_value = _operator_add_impl(module, a, b);
64
65 exit:
66 return return_value;
67 }
68
69 PyDoc_STRVAR(_operator_sub__doc__,
70 "sub($module, a, b, /)\n"
71 "--\n"
72 "\n"
73 "Same as a - b.");
74
75 #define _OPERATOR_SUB_METHODDEF \
76 {"sub", _PyCFunction_CAST(_operator_sub), METH_FASTCALL, _operator_sub__doc__},
77
78 static PyObject *
79 _operator_sub_impl(PyObject *module, PyObject *a, PyObject *b);
80
81 static PyObject *
82 _operator_sub(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
83 {
84 PyObject *return_value = NULL;
85 PyObject *a;
86 PyObject *b;
87
88 if (!_PyArg_CheckPositional("sub", nargs, 2, 2)) {
89 goto exit;
90 }
91 a = args[0];
92 b = args[1];
93 return_value = _operator_sub_impl(module, a, b);
94
95 exit:
96 return return_value;
97 }
98
99 PyDoc_STRVAR(_operator_mul__doc__,
100 "mul($module, a, b, /)\n"
101 "--\n"
102 "\n"
103 "Same as a * b.");
104
105 #define _OPERATOR_MUL_METHODDEF \
106 {"mul", _PyCFunction_CAST(_operator_mul), METH_FASTCALL, _operator_mul__doc__},
107
108 static PyObject *
109 _operator_mul_impl(PyObject *module, PyObject *a, PyObject *b);
110
111 static PyObject *
112 _operator_mul(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
113 {
114 PyObject *return_value = NULL;
115 PyObject *a;
116 PyObject *b;
117
118 if (!_PyArg_CheckPositional("mul", nargs, 2, 2)) {
119 goto exit;
120 }
121 a = args[0];
122 b = args[1];
123 return_value = _operator_mul_impl(module, a, b);
124
125 exit:
126 return return_value;
127 }
128
129 PyDoc_STRVAR(_operator_matmul__doc__,
130 "matmul($module, a, b, /)\n"
131 "--\n"
132 "\n"
133 "Same as a @ b.");
134
135 #define _OPERATOR_MATMUL_METHODDEF \
136 {"matmul", _PyCFunction_CAST(_operator_matmul), METH_FASTCALL, _operator_matmul__doc__},
137
138 static PyObject *
139 _operator_matmul_impl(PyObject *module, PyObject *a, PyObject *b);
140
141 static PyObject *
142 _operator_matmul(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
143 {
144 PyObject *return_value = NULL;
145 PyObject *a;
146 PyObject *b;
147
148 if (!_PyArg_CheckPositional("matmul", nargs, 2, 2)) {
149 goto exit;
150 }
151 a = args[0];
152 b = args[1];
153 return_value = _operator_matmul_impl(module, a, b);
154
155 exit:
156 return return_value;
157 }
158
159 PyDoc_STRVAR(_operator_floordiv__doc__,
160 "floordiv($module, a, b, /)\n"
161 "--\n"
162 "\n"
163 "Same as a // b.");
164
165 #define _OPERATOR_FLOORDIV_METHODDEF \
166 {"floordiv", _PyCFunction_CAST(_operator_floordiv), METH_FASTCALL, _operator_floordiv__doc__},
167
168 static PyObject *
169 _operator_floordiv_impl(PyObject *module, PyObject *a, PyObject *b);
170
171 static PyObject *
172 _operator_floordiv(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
173 {
174 PyObject *return_value = NULL;
175 PyObject *a;
176 PyObject *b;
177
178 if (!_PyArg_CheckPositional("floordiv", nargs, 2, 2)) {
179 goto exit;
180 }
181 a = args[0];
182 b = args[1];
183 return_value = _operator_floordiv_impl(module, a, b);
184
185 exit:
186 return return_value;
187 }
188
189 PyDoc_STRVAR(_operator_truediv__doc__,
190 "truediv($module, a, b, /)\n"
191 "--\n"
192 "\n"
193 "Same as a / b.");
194
195 #define _OPERATOR_TRUEDIV_METHODDEF \
196 {"truediv", _PyCFunction_CAST(_operator_truediv), METH_FASTCALL, _operator_truediv__doc__},
197
198 static PyObject *
199 _operator_truediv_impl(PyObject *module, PyObject *a, PyObject *b);
200
201 static PyObject *
202 _operator_truediv(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
203 {
204 PyObject *return_value = NULL;
205 PyObject *a;
206 PyObject *b;
207
208 if (!_PyArg_CheckPositional("truediv", nargs, 2, 2)) {
209 goto exit;
210 }
211 a = args[0];
212 b = args[1];
213 return_value = _operator_truediv_impl(module, a, b);
214
215 exit:
216 return return_value;
217 }
218
219 PyDoc_STRVAR(_operator_mod__doc__,
220 "mod($module, a, b, /)\n"
221 "--\n"
222 "\n"
223 "Same as a % b.");
224
225 #define _OPERATOR_MOD_METHODDEF \
226 {"mod", _PyCFunction_CAST(_operator_mod), METH_FASTCALL, _operator_mod__doc__},
227
228 static PyObject *
229 _operator_mod_impl(PyObject *module, PyObject *a, PyObject *b);
230
231 static PyObject *
232 _operator_mod(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
233 {
234 PyObject *return_value = NULL;
235 PyObject *a;
236 PyObject *b;
237
238 if (!_PyArg_CheckPositional("mod", nargs, 2, 2)) {
239 goto exit;
240 }
241 a = args[0];
242 b = args[1];
243 return_value = _operator_mod_impl(module, a, b);
244
245 exit:
246 return return_value;
247 }
248
249 PyDoc_STRVAR(_operator_neg__doc__,
250 "neg($module, a, /)\n"
251 "--\n"
252 "\n"
253 "Same as -a.");
254
255 #define _OPERATOR_NEG_METHODDEF \
256 {"neg", (PyCFunction)_operator_neg, METH_O, _operator_neg__doc__},
257
258 PyDoc_STRVAR(_operator_pos__doc__,
259 "pos($module, a, /)\n"
260 "--\n"
261 "\n"
262 "Same as +a.");
263
264 #define _OPERATOR_POS_METHODDEF \
265 {"pos", (PyCFunction)_operator_pos, METH_O, _operator_pos__doc__},
266
267 PyDoc_STRVAR(_operator_abs__doc__,
268 "abs($module, a, /)\n"
269 "--\n"
270 "\n"
271 "Same as abs(a).");
272
273 #define _OPERATOR_ABS_METHODDEF \
274 {"abs", (PyCFunction)_operator_abs, METH_O, _operator_abs__doc__},
275
276 PyDoc_STRVAR(_operator_inv__doc__,
277 "inv($module, a, /)\n"
278 "--\n"
279 "\n"
280 "Same as ~a.");
281
282 #define _OPERATOR_INV_METHODDEF \
283 {"inv", (PyCFunction)_operator_inv, METH_O, _operator_inv__doc__},
284
285 PyDoc_STRVAR(_operator_invert__doc__,
286 "invert($module, a, /)\n"
287 "--\n"
288 "\n"
289 "Same as ~a.");
290
291 #define _OPERATOR_INVERT_METHODDEF \
292 {"invert", (PyCFunction)_operator_invert, METH_O, _operator_invert__doc__},
293
294 PyDoc_STRVAR(_operator_lshift__doc__,
295 "lshift($module, a, b, /)\n"
296 "--\n"
297 "\n"
298 "Same as a << b.");
299
300 #define _OPERATOR_LSHIFT_METHODDEF \
301 {"lshift", _PyCFunction_CAST(_operator_lshift), METH_FASTCALL, _operator_lshift__doc__},
302
303 static PyObject *
304 _operator_lshift_impl(PyObject *module, PyObject *a, PyObject *b);
305
306 static PyObject *
307 _operator_lshift(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
308 {
309 PyObject *return_value = NULL;
310 PyObject *a;
311 PyObject *b;
312
313 if (!_PyArg_CheckPositional("lshift", nargs, 2, 2)) {
314 goto exit;
315 }
316 a = args[0];
317 b = args[1];
318 return_value = _operator_lshift_impl(module, a, b);
319
320 exit:
321 return return_value;
322 }
323
324 PyDoc_STRVAR(_operator_rshift__doc__,
325 "rshift($module, a, b, /)\n"
326 "--\n"
327 "\n"
328 "Same as a >> b.");
329
330 #define _OPERATOR_RSHIFT_METHODDEF \
331 {"rshift", _PyCFunction_CAST(_operator_rshift), METH_FASTCALL, _operator_rshift__doc__},
332
333 static PyObject *
334 _operator_rshift_impl(PyObject *module, PyObject *a, PyObject *b);
335
336 static PyObject *
337 _operator_rshift(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
338 {
339 PyObject *return_value = NULL;
340 PyObject *a;
341 PyObject *b;
342
343 if (!_PyArg_CheckPositional("rshift", nargs, 2, 2)) {
344 goto exit;
345 }
346 a = args[0];
347 b = args[1];
348 return_value = _operator_rshift_impl(module, a, b);
349
350 exit:
351 return return_value;
352 }
353
354 PyDoc_STRVAR(_operator_not___doc__,
355 "not_($module, a, /)\n"
356 "--\n"
357 "\n"
358 "Same as not a.");
359
360 #define _OPERATOR_NOT__METHODDEF \
361 {"not_", (PyCFunction)_operator_not_, METH_O, _operator_not___doc__},
362
363 static int
364 _operator_not__impl(PyObject *module, PyObject *a);
365
366 static PyObject *
367 _operator_not_(PyObject *module, PyObject *a)
368 {
369 PyObject *return_value = NULL;
370 int _return_value;
371
372 _return_value = _operator_not__impl(module, a);
373 if ((_return_value == -1) && PyErr_Occurred()) {
374 goto exit;
375 }
376 return_value = PyBool_FromLong((long)_return_value);
377
378 exit:
379 return return_value;
380 }
381
382 PyDoc_STRVAR(_operator_and___doc__,
383 "and_($module, a, b, /)\n"
384 "--\n"
385 "\n"
386 "Same as a & b.");
387
388 #define _OPERATOR_AND__METHODDEF \
389 {"and_", _PyCFunction_CAST(_operator_and_), METH_FASTCALL, _operator_and___doc__},
390
391 static PyObject *
392 _operator_and__impl(PyObject *module, PyObject *a, PyObject *b);
393
394 static PyObject *
395 _operator_and_(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
396 {
397 PyObject *return_value = NULL;
398 PyObject *a;
399 PyObject *b;
400
401 if (!_PyArg_CheckPositional("and_", nargs, 2, 2)) {
402 goto exit;
403 }
404 a = args[0];
405 b = args[1];
406 return_value = _operator_and__impl(module, a, b);
407
408 exit:
409 return return_value;
410 }
411
412 PyDoc_STRVAR(_operator_xor__doc__,
413 "xor($module, a, b, /)\n"
414 "--\n"
415 "\n"
416 "Same as a ^ b.");
417
418 #define _OPERATOR_XOR_METHODDEF \
419 {"xor", _PyCFunction_CAST(_operator_xor), METH_FASTCALL, _operator_xor__doc__},
420
421 static PyObject *
422 _operator_xor_impl(PyObject *module, PyObject *a, PyObject *b);
423
424 static PyObject *
425 _operator_xor(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
426 {
427 PyObject *return_value = NULL;
428 PyObject *a;
429 PyObject *b;
430
431 if (!_PyArg_CheckPositional("xor", nargs, 2, 2)) {
432 goto exit;
433 }
434 a = args[0];
435 b = args[1];
436 return_value = _operator_xor_impl(module, a, b);
437
438 exit:
439 return return_value;
440 }
441
442 PyDoc_STRVAR(_operator_or___doc__,
443 "or_($module, a, b, /)\n"
444 "--\n"
445 "\n"
446 "Same as a | b.");
447
448 #define _OPERATOR_OR__METHODDEF \
449 {"or_", _PyCFunction_CAST(_operator_or_), METH_FASTCALL, _operator_or___doc__},
450
451 static PyObject *
452 _operator_or__impl(PyObject *module, PyObject *a, PyObject *b);
453
454 static PyObject *
455 _operator_or_(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
456 {
457 PyObject *return_value = NULL;
458 PyObject *a;
459 PyObject *b;
460
461 if (!_PyArg_CheckPositional("or_", nargs, 2, 2)) {
462 goto exit;
463 }
464 a = args[0];
465 b = args[1];
466 return_value = _operator_or__impl(module, a, b);
467
468 exit:
469 return return_value;
470 }
471
472 PyDoc_STRVAR(_operator_iadd__doc__,
473 "iadd($module, a, b, /)\n"
474 "--\n"
475 "\n"
476 "Same as a += b.");
477
478 #define _OPERATOR_IADD_METHODDEF \
479 {"iadd", _PyCFunction_CAST(_operator_iadd), METH_FASTCALL, _operator_iadd__doc__},
480
481 static PyObject *
482 _operator_iadd_impl(PyObject *module, PyObject *a, PyObject *b);
483
484 static PyObject *
485 _operator_iadd(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
486 {
487 PyObject *return_value = NULL;
488 PyObject *a;
489 PyObject *b;
490
491 if (!_PyArg_CheckPositional("iadd", nargs, 2, 2)) {
492 goto exit;
493 }
494 a = args[0];
495 b = args[1];
496 return_value = _operator_iadd_impl(module, a, b);
497
498 exit:
499 return return_value;
500 }
501
502 PyDoc_STRVAR(_operator_isub__doc__,
503 "isub($module, a, b, /)\n"
504 "--\n"
505 "\n"
506 "Same as a -= b.");
507
508 #define _OPERATOR_ISUB_METHODDEF \
509 {"isub", _PyCFunction_CAST(_operator_isub), METH_FASTCALL, _operator_isub__doc__},
510
511 static PyObject *
512 _operator_isub_impl(PyObject *module, PyObject *a, PyObject *b);
513
514 static PyObject *
515 _operator_isub(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
516 {
517 PyObject *return_value = NULL;
518 PyObject *a;
519 PyObject *b;
520
521 if (!_PyArg_CheckPositional("isub", nargs, 2, 2)) {
522 goto exit;
523 }
524 a = args[0];
525 b = args[1];
526 return_value = _operator_isub_impl(module, a, b);
527
528 exit:
529 return return_value;
530 }
531
532 PyDoc_STRVAR(_operator_imul__doc__,
533 "imul($module, a, b, /)\n"
534 "--\n"
535 "\n"
536 "Same as a *= b.");
537
538 #define _OPERATOR_IMUL_METHODDEF \
539 {"imul", _PyCFunction_CAST(_operator_imul), METH_FASTCALL, _operator_imul__doc__},
540
541 static PyObject *
542 _operator_imul_impl(PyObject *module, PyObject *a, PyObject *b);
543
544 static PyObject *
545 _operator_imul(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
546 {
547 PyObject *return_value = NULL;
548 PyObject *a;
549 PyObject *b;
550
551 if (!_PyArg_CheckPositional("imul", nargs, 2, 2)) {
552 goto exit;
553 }
554 a = args[0];
555 b = args[1];
556 return_value = _operator_imul_impl(module, a, b);
557
558 exit:
559 return return_value;
560 }
561
562 PyDoc_STRVAR(_operator_imatmul__doc__,
563 "imatmul($module, a, b, /)\n"
564 "--\n"
565 "\n"
566 "Same as a @= b.");
567
568 #define _OPERATOR_IMATMUL_METHODDEF \
569 {"imatmul", _PyCFunction_CAST(_operator_imatmul), METH_FASTCALL, _operator_imatmul__doc__},
570
571 static PyObject *
572 _operator_imatmul_impl(PyObject *module, PyObject *a, PyObject *b);
573
574 static PyObject *
575 _operator_imatmul(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
576 {
577 PyObject *return_value = NULL;
578 PyObject *a;
579 PyObject *b;
580
581 if (!_PyArg_CheckPositional("imatmul", nargs, 2, 2)) {
582 goto exit;
583 }
584 a = args[0];
585 b = args[1];
586 return_value = _operator_imatmul_impl(module, a, b);
587
588 exit:
589 return return_value;
590 }
591
592 PyDoc_STRVAR(_operator_ifloordiv__doc__,
593 "ifloordiv($module, a, b, /)\n"
594 "--\n"
595 "\n"
596 "Same as a //= b.");
597
598 #define _OPERATOR_IFLOORDIV_METHODDEF \
599 {"ifloordiv", _PyCFunction_CAST(_operator_ifloordiv), METH_FASTCALL, _operator_ifloordiv__doc__},
600
601 static PyObject *
602 _operator_ifloordiv_impl(PyObject *module, PyObject *a, PyObject *b);
603
604 static PyObject *
605 _operator_ifloordiv(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
606 {
607 PyObject *return_value = NULL;
608 PyObject *a;
609 PyObject *b;
610
611 if (!_PyArg_CheckPositional("ifloordiv", nargs, 2, 2)) {
612 goto exit;
613 }
614 a = args[0];
615 b = args[1];
616 return_value = _operator_ifloordiv_impl(module, a, b);
617
618 exit:
619 return return_value;
620 }
621
622 PyDoc_STRVAR(_operator_itruediv__doc__,
623 "itruediv($module, a, b, /)\n"
624 "--\n"
625 "\n"
626 "Same as a /= b.");
627
628 #define _OPERATOR_ITRUEDIV_METHODDEF \
629 {"itruediv", _PyCFunction_CAST(_operator_itruediv), METH_FASTCALL, _operator_itruediv__doc__},
630
631 static PyObject *
632 _operator_itruediv_impl(PyObject *module, PyObject *a, PyObject *b);
633
634 static PyObject *
635 _operator_itruediv(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
636 {
637 PyObject *return_value = NULL;
638 PyObject *a;
639 PyObject *b;
640
641 if (!_PyArg_CheckPositional("itruediv", nargs, 2, 2)) {
642 goto exit;
643 }
644 a = args[0];
645 b = args[1];
646 return_value = _operator_itruediv_impl(module, a, b);
647
648 exit:
649 return return_value;
650 }
651
652 PyDoc_STRVAR(_operator_imod__doc__,
653 "imod($module, a, b, /)\n"
654 "--\n"
655 "\n"
656 "Same as a %= b.");
657
658 #define _OPERATOR_IMOD_METHODDEF \
659 {"imod", _PyCFunction_CAST(_operator_imod), METH_FASTCALL, _operator_imod__doc__},
660
661 static PyObject *
662 _operator_imod_impl(PyObject *module, PyObject *a, PyObject *b);
663
664 static PyObject *
665 _operator_imod(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
666 {
667 PyObject *return_value = NULL;
668 PyObject *a;
669 PyObject *b;
670
671 if (!_PyArg_CheckPositional("imod", nargs, 2, 2)) {
672 goto exit;
673 }
674 a = args[0];
675 b = args[1];
676 return_value = _operator_imod_impl(module, a, b);
677
678 exit:
679 return return_value;
680 }
681
682 PyDoc_STRVAR(_operator_ilshift__doc__,
683 "ilshift($module, a, b, /)\n"
684 "--\n"
685 "\n"
686 "Same as a <<= b.");
687
688 #define _OPERATOR_ILSHIFT_METHODDEF \
689 {"ilshift", _PyCFunction_CAST(_operator_ilshift), METH_FASTCALL, _operator_ilshift__doc__},
690
691 static PyObject *
692 _operator_ilshift_impl(PyObject *module, PyObject *a, PyObject *b);
693
694 static PyObject *
695 _operator_ilshift(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
696 {
697 PyObject *return_value = NULL;
698 PyObject *a;
699 PyObject *b;
700
701 if (!_PyArg_CheckPositional("ilshift", nargs, 2, 2)) {
702 goto exit;
703 }
704 a = args[0];
705 b = args[1];
706 return_value = _operator_ilshift_impl(module, a, b);
707
708 exit:
709 return return_value;
710 }
711
712 PyDoc_STRVAR(_operator_irshift__doc__,
713 "irshift($module, a, b, /)\n"
714 "--\n"
715 "\n"
716 "Same as a >>= b.");
717
718 #define _OPERATOR_IRSHIFT_METHODDEF \
719 {"irshift", _PyCFunction_CAST(_operator_irshift), METH_FASTCALL, _operator_irshift__doc__},
720
721 static PyObject *
722 _operator_irshift_impl(PyObject *module, PyObject *a, PyObject *b);
723
724 static PyObject *
725 _operator_irshift(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
726 {
727 PyObject *return_value = NULL;
728 PyObject *a;
729 PyObject *b;
730
731 if (!_PyArg_CheckPositional("irshift", nargs, 2, 2)) {
732 goto exit;
733 }
734 a = args[0];
735 b = args[1];
736 return_value = _operator_irshift_impl(module, a, b);
737
738 exit:
739 return return_value;
740 }
741
742 PyDoc_STRVAR(_operator_iand__doc__,
743 "iand($module, a, b, /)\n"
744 "--\n"
745 "\n"
746 "Same as a &= b.");
747
748 #define _OPERATOR_IAND_METHODDEF \
749 {"iand", _PyCFunction_CAST(_operator_iand), METH_FASTCALL, _operator_iand__doc__},
750
751 static PyObject *
752 _operator_iand_impl(PyObject *module, PyObject *a, PyObject *b);
753
754 static PyObject *
755 _operator_iand(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
756 {
757 PyObject *return_value = NULL;
758 PyObject *a;
759 PyObject *b;
760
761 if (!_PyArg_CheckPositional("iand", nargs, 2, 2)) {
762 goto exit;
763 }
764 a = args[0];
765 b = args[1];
766 return_value = _operator_iand_impl(module, a, b);
767
768 exit:
769 return return_value;
770 }
771
772 PyDoc_STRVAR(_operator_ixor__doc__,
773 "ixor($module, a, b, /)\n"
774 "--\n"
775 "\n"
776 "Same as a ^= b.");
777
778 #define _OPERATOR_IXOR_METHODDEF \
779 {"ixor", _PyCFunction_CAST(_operator_ixor), METH_FASTCALL, _operator_ixor__doc__},
780
781 static PyObject *
782 _operator_ixor_impl(PyObject *module, PyObject *a, PyObject *b);
783
784 static PyObject *
785 _operator_ixor(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
786 {
787 PyObject *return_value = NULL;
788 PyObject *a;
789 PyObject *b;
790
791 if (!_PyArg_CheckPositional("ixor", nargs, 2, 2)) {
792 goto exit;
793 }
794 a = args[0];
795 b = args[1];
796 return_value = _operator_ixor_impl(module, a, b);
797
798 exit:
799 return return_value;
800 }
801
802 PyDoc_STRVAR(_operator_ior__doc__,
803 "ior($module, a, b, /)\n"
804 "--\n"
805 "\n"
806 "Same as a |= b.");
807
808 #define _OPERATOR_IOR_METHODDEF \
809 {"ior", _PyCFunction_CAST(_operator_ior), METH_FASTCALL, _operator_ior__doc__},
810
811 static PyObject *
812 _operator_ior_impl(PyObject *module, PyObject *a, PyObject *b);
813
814 static PyObject *
815 _operator_ior(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
816 {
817 PyObject *return_value = NULL;
818 PyObject *a;
819 PyObject *b;
820
821 if (!_PyArg_CheckPositional("ior", nargs, 2, 2)) {
822 goto exit;
823 }
824 a = args[0];
825 b = args[1];
826 return_value = _operator_ior_impl(module, a, b);
827
828 exit:
829 return return_value;
830 }
831
832 PyDoc_STRVAR(_operator_concat__doc__,
833 "concat($module, a, b, /)\n"
834 "--\n"
835 "\n"
836 "Same as a + b, for a and b sequences.");
837
838 #define _OPERATOR_CONCAT_METHODDEF \
839 {"concat", _PyCFunction_CAST(_operator_concat), METH_FASTCALL, _operator_concat__doc__},
840
841 static PyObject *
842 _operator_concat_impl(PyObject *module, PyObject *a, PyObject *b);
843
844 static PyObject *
845 _operator_concat(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
846 {
847 PyObject *return_value = NULL;
848 PyObject *a;
849 PyObject *b;
850
851 if (!_PyArg_CheckPositional("concat", nargs, 2, 2)) {
852 goto exit;
853 }
854 a = args[0];
855 b = args[1];
856 return_value = _operator_concat_impl(module, a, b);
857
858 exit:
859 return return_value;
860 }
861
862 PyDoc_STRVAR(_operator_iconcat__doc__,
863 "iconcat($module, a, b, /)\n"
864 "--\n"
865 "\n"
866 "Same as a += b, for a and b sequences.");
867
868 #define _OPERATOR_ICONCAT_METHODDEF \
869 {"iconcat", _PyCFunction_CAST(_operator_iconcat), METH_FASTCALL, _operator_iconcat__doc__},
870
871 static PyObject *
872 _operator_iconcat_impl(PyObject *module, PyObject *a, PyObject *b);
873
874 static PyObject *
875 _operator_iconcat(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
876 {
877 PyObject *return_value = NULL;
878 PyObject *a;
879 PyObject *b;
880
881 if (!_PyArg_CheckPositional("iconcat", nargs, 2, 2)) {
882 goto exit;
883 }
884 a = args[0];
885 b = args[1];
886 return_value = _operator_iconcat_impl(module, a, b);
887
888 exit:
889 return return_value;
890 }
891
892 PyDoc_STRVAR(_operator_contains__doc__,
893 "contains($module, a, b, /)\n"
894 "--\n"
895 "\n"
896 "Same as b in a (note reversed operands).");
897
898 #define _OPERATOR_CONTAINS_METHODDEF \
899 {"contains", _PyCFunction_CAST(_operator_contains), METH_FASTCALL, _operator_contains__doc__},
900
901 static int
902 _operator_contains_impl(PyObject *module, PyObject *a, PyObject *b);
903
904 static PyObject *
905 _operator_contains(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
906 {
907 PyObject *return_value = NULL;
908 PyObject *a;
909 PyObject *b;
910 int _return_value;
911
912 if (!_PyArg_CheckPositional("contains", nargs, 2, 2)) {
913 goto exit;
914 }
915 a = args[0];
916 b = args[1];
917 _return_value = _operator_contains_impl(module, a, b);
918 if ((_return_value == -1) && PyErr_Occurred()) {
919 goto exit;
920 }
921 return_value = PyBool_FromLong((long)_return_value);
922
923 exit:
924 return return_value;
925 }
926
927 PyDoc_STRVAR(_operator_indexOf__doc__,
928 "indexOf($module, a, b, /)\n"
929 "--\n"
930 "\n"
931 "Return the first index of b in a.");
932
933 #define _OPERATOR_INDEXOF_METHODDEF \
934 {"indexOf", _PyCFunction_CAST(_operator_indexOf), METH_FASTCALL, _operator_indexOf__doc__},
935
936 static Py_ssize_t
937 _operator_indexOf_impl(PyObject *module, PyObject *a, PyObject *b);
938
939 static PyObject *
940 _operator_indexOf(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
941 {
942 PyObject *return_value = NULL;
943 PyObject *a;
944 PyObject *b;
945 Py_ssize_t _return_value;
946
947 if (!_PyArg_CheckPositional("indexOf", nargs, 2, 2)) {
948 goto exit;
949 }
950 a = args[0];
951 b = args[1];
952 _return_value = _operator_indexOf_impl(module, a, b);
953 if ((_return_value == -1) && PyErr_Occurred()) {
954 goto exit;
955 }
956 return_value = PyLong_FromSsize_t(_return_value);
957
958 exit:
959 return return_value;
960 }
961
962 PyDoc_STRVAR(_operator_countOf__doc__,
963 "countOf($module, a, b, /)\n"
964 "--\n"
965 "\n"
966 "Return the number of items in a which are, or which equal, b.");
967
968 #define _OPERATOR_COUNTOF_METHODDEF \
969 {"countOf", _PyCFunction_CAST(_operator_countOf), METH_FASTCALL, _operator_countOf__doc__},
970
971 static Py_ssize_t
972 _operator_countOf_impl(PyObject *module, PyObject *a, PyObject *b);
973
974 static PyObject *
975 _operator_countOf(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
976 {
977 PyObject *return_value = NULL;
978 PyObject *a;
979 PyObject *b;
980 Py_ssize_t _return_value;
981
982 if (!_PyArg_CheckPositional("countOf", nargs, 2, 2)) {
983 goto exit;
984 }
985 a = args[0];
986 b = args[1];
987 _return_value = _operator_countOf_impl(module, a, b);
988 if ((_return_value == -1) && PyErr_Occurred()) {
989 goto exit;
990 }
991 return_value = PyLong_FromSsize_t(_return_value);
992
993 exit:
994 return return_value;
995 }
996
997 PyDoc_STRVAR(_operator_getitem__doc__,
998 "getitem($module, a, b, /)\n"
999 "--\n"
1000 "\n"
1001 "Same as a[b].");
1002
1003 #define _OPERATOR_GETITEM_METHODDEF \
1004 {"getitem", _PyCFunction_CAST(_operator_getitem), METH_FASTCALL, _operator_getitem__doc__},
1005
1006 static PyObject *
1007 _operator_getitem_impl(PyObject *module, PyObject *a, PyObject *b);
1008
1009 static PyObject *
1010 _operator_getitem(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1011 {
1012 PyObject *return_value = NULL;
1013 PyObject *a;
1014 PyObject *b;
1015
1016 if (!_PyArg_CheckPositional("getitem", nargs, 2, 2)) {
1017 goto exit;
1018 }
1019 a = args[0];
1020 b = args[1];
1021 return_value = _operator_getitem_impl(module, a, b);
1022
1023 exit:
1024 return return_value;
1025 }
1026
1027 PyDoc_STRVAR(_operator_setitem__doc__,
1028 "setitem($module, a, b, c, /)\n"
1029 "--\n"
1030 "\n"
1031 "Same as a[b] = c.");
1032
1033 #define _OPERATOR_SETITEM_METHODDEF \
1034 {"setitem", _PyCFunction_CAST(_operator_setitem), METH_FASTCALL, _operator_setitem__doc__},
1035
1036 static PyObject *
1037 _operator_setitem_impl(PyObject *module, PyObject *a, PyObject *b,
1038 PyObject *c);
1039
1040 static PyObject *
1041 _operator_setitem(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1042 {
1043 PyObject *return_value = NULL;
1044 PyObject *a;
1045 PyObject *b;
1046 PyObject *c;
1047
1048 if (!_PyArg_CheckPositional("setitem", nargs, 3, 3)) {
1049 goto exit;
1050 }
1051 a = args[0];
1052 b = args[1];
1053 c = args[2];
1054 return_value = _operator_setitem_impl(module, a, b, c);
1055
1056 exit:
1057 return return_value;
1058 }
1059
1060 PyDoc_STRVAR(_operator_delitem__doc__,
1061 "delitem($module, a, b, /)\n"
1062 "--\n"
1063 "\n"
1064 "Same as del a[b].");
1065
1066 #define _OPERATOR_DELITEM_METHODDEF \
1067 {"delitem", _PyCFunction_CAST(_operator_delitem), METH_FASTCALL, _operator_delitem__doc__},
1068
1069 static PyObject *
1070 _operator_delitem_impl(PyObject *module, PyObject *a, PyObject *b);
1071
1072 static PyObject *
1073 _operator_delitem(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1074 {
1075 PyObject *return_value = NULL;
1076 PyObject *a;
1077 PyObject *b;
1078
1079 if (!_PyArg_CheckPositional("delitem", nargs, 2, 2)) {
1080 goto exit;
1081 }
1082 a = args[0];
1083 b = args[1];
1084 return_value = _operator_delitem_impl(module, a, b);
1085
1086 exit:
1087 return return_value;
1088 }
1089
1090 PyDoc_STRVAR(_operator_eq__doc__,
1091 "eq($module, a, b, /)\n"
1092 "--\n"
1093 "\n"
1094 "Same as a == b.");
1095
1096 #define _OPERATOR_EQ_METHODDEF \
1097 {"eq", _PyCFunction_CAST(_operator_eq), METH_FASTCALL, _operator_eq__doc__},
1098
1099 static PyObject *
1100 _operator_eq_impl(PyObject *module, PyObject *a, PyObject *b);
1101
1102 static PyObject *
1103 _operator_eq(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1104 {
1105 PyObject *return_value = NULL;
1106 PyObject *a;
1107 PyObject *b;
1108
1109 if (!_PyArg_CheckPositional("eq", nargs, 2, 2)) {
1110 goto exit;
1111 }
1112 a = args[0];
1113 b = args[1];
1114 return_value = _operator_eq_impl(module, a, b);
1115
1116 exit:
1117 return return_value;
1118 }
1119
1120 PyDoc_STRVAR(_operator_ne__doc__,
1121 "ne($module, a, b, /)\n"
1122 "--\n"
1123 "\n"
1124 "Same as a != b.");
1125
1126 #define _OPERATOR_NE_METHODDEF \
1127 {"ne", _PyCFunction_CAST(_operator_ne), METH_FASTCALL, _operator_ne__doc__},
1128
1129 static PyObject *
1130 _operator_ne_impl(PyObject *module, PyObject *a, PyObject *b);
1131
1132 static PyObject *
1133 _operator_ne(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1134 {
1135 PyObject *return_value = NULL;
1136 PyObject *a;
1137 PyObject *b;
1138
1139 if (!_PyArg_CheckPositional("ne", nargs, 2, 2)) {
1140 goto exit;
1141 }
1142 a = args[0];
1143 b = args[1];
1144 return_value = _operator_ne_impl(module, a, b);
1145
1146 exit:
1147 return return_value;
1148 }
1149
1150 PyDoc_STRVAR(_operator_lt__doc__,
1151 "lt($module, a, b, /)\n"
1152 "--\n"
1153 "\n"
1154 "Same as a < b.");
1155
1156 #define _OPERATOR_LT_METHODDEF \
1157 {"lt", _PyCFunction_CAST(_operator_lt), METH_FASTCALL, _operator_lt__doc__},
1158
1159 static PyObject *
1160 _operator_lt_impl(PyObject *module, PyObject *a, PyObject *b);
1161
1162 static PyObject *
1163 _operator_lt(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1164 {
1165 PyObject *return_value = NULL;
1166 PyObject *a;
1167 PyObject *b;
1168
1169 if (!_PyArg_CheckPositional("lt", nargs, 2, 2)) {
1170 goto exit;
1171 }
1172 a = args[0];
1173 b = args[1];
1174 return_value = _operator_lt_impl(module, a, b);
1175
1176 exit:
1177 return return_value;
1178 }
1179
1180 PyDoc_STRVAR(_operator_le__doc__,
1181 "le($module, a, b, /)\n"
1182 "--\n"
1183 "\n"
1184 "Same as a <= b.");
1185
1186 #define _OPERATOR_LE_METHODDEF \
1187 {"le", _PyCFunction_CAST(_operator_le), METH_FASTCALL, _operator_le__doc__},
1188
1189 static PyObject *
1190 _operator_le_impl(PyObject *module, PyObject *a, PyObject *b);
1191
1192 static PyObject *
1193 _operator_le(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1194 {
1195 PyObject *return_value = NULL;
1196 PyObject *a;
1197 PyObject *b;
1198
1199 if (!_PyArg_CheckPositional("le", nargs, 2, 2)) {
1200 goto exit;
1201 }
1202 a = args[0];
1203 b = args[1];
1204 return_value = _operator_le_impl(module, a, b);
1205
1206 exit:
1207 return return_value;
1208 }
1209
1210 PyDoc_STRVAR(_operator_gt__doc__,
1211 "gt($module, a, b, /)\n"
1212 "--\n"
1213 "\n"
1214 "Same as a > b.");
1215
1216 #define _OPERATOR_GT_METHODDEF \
1217 {"gt", _PyCFunction_CAST(_operator_gt), METH_FASTCALL, _operator_gt__doc__},
1218
1219 static PyObject *
1220 _operator_gt_impl(PyObject *module, PyObject *a, PyObject *b);
1221
1222 static PyObject *
1223 _operator_gt(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1224 {
1225 PyObject *return_value = NULL;
1226 PyObject *a;
1227 PyObject *b;
1228
1229 if (!_PyArg_CheckPositional("gt", nargs, 2, 2)) {
1230 goto exit;
1231 }
1232 a = args[0];
1233 b = args[1];
1234 return_value = _operator_gt_impl(module, a, b);
1235
1236 exit:
1237 return return_value;
1238 }
1239
1240 PyDoc_STRVAR(_operator_ge__doc__,
1241 "ge($module, a, b, /)\n"
1242 "--\n"
1243 "\n"
1244 "Same as a >= b.");
1245
1246 #define _OPERATOR_GE_METHODDEF \
1247 {"ge", _PyCFunction_CAST(_operator_ge), METH_FASTCALL, _operator_ge__doc__},
1248
1249 static PyObject *
1250 _operator_ge_impl(PyObject *module, PyObject *a, PyObject *b);
1251
1252 static PyObject *
1253 _operator_ge(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1254 {
1255 PyObject *return_value = NULL;
1256 PyObject *a;
1257 PyObject *b;
1258
1259 if (!_PyArg_CheckPositional("ge", nargs, 2, 2)) {
1260 goto exit;
1261 }
1262 a = args[0];
1263 b = args[1];
1264 return_value = _operator_ge_impl(module, a, b);
1265
1266 exit:
1267 return return_value;
1268 }
1269
1270 PyDoc_STRVAR(_operator_pow__doc__,
1271 "pow($module, a, b, /)\n"
1272 "--\n"
1273 "\n"
1274 "Same as a ** b.");
1275
1276 #define _OPERATOR_POW_METHODDEF \
1277 {"pow", _PyCFunction_CAST(_operator_pow), METH_FASTCALL, _operator_pow__doc__},
1278
1279 static PyObject *
1280 _operator_pow_impl(PyObject *module, PyObject *a, PyObject *b);
1281
1282 static PyObject *
1283 _operator_pow(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1284 {
1285 PyObject *return_value = NULL;
1286 PyObject *a;
1287 PyObject *b;
1288
1289 if (!_PyArg_CheckPositional("pow", nargs, 2, 2)) {
1290 goto exit;
1291 }
1292 a = args[0];
1293 b = args[1];
1294 return_value = _operator_pow_impl(module, a, b);
1295
1296 exit:
1297 return return_value;
1298 }
1299
1300 PyDoc_STRVAR(_operator_ipow__doc__,
1301 "ipow($module, a, b, /)\n"
1302 "--\n"
1303 "\n"
1304 "Same as a **= b.");
1305
1306 #define _OPERATOR_IPOW_METHODDEF \
1307 {"ipow", _PyCFunction_CAST(_operator_ipow), METH_FASTCALL, _operator_ipow__doc__},
1308
1309 static PyObject *
1310 _operator_ipow_impl(PyObject *module, PyObject *a, PyObject *b);
1311
1312 static PyObject *
1313 _operator_ipow(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1314 {
1315 PyObject *return_value = NULL;
1316 PyObject *a;
1317 PyObject *b;
1318
1319 if (!_PyArg_CheckPositional("ipow", nargs, 2, 2)) {
1320 goto exit;
1321 }
1322 a = args[0];
1323 b = args[1];
1324 return_value = _operator_ipow_impl(module, a, b);
1325
1326 exit:
1327 return return_value;
1328 }
1329
1330 PyDoc_STRVAR(_operator_index__doc__,
1331 "index($module, a, /)\n"
1332 "--\n"
1333 "\n"
1334 "Same as a.__index__()");
1335
1336 #define _OPERATOR_INDEX_METHODDEF \
1337 {"index", (PyCFunction)_operator_index, METH_O, _operator_index__doc__},
1338
1339 PyDoc_STRVAR(_operator_is___doc__,
1340 "is_($module, a, b, /)\n"
1341 "--\n"
1342 "\n"
1343 "Same as a is b.");
1344
1345 #define _OPERATOR_IS__METHODDEF \
1346 {"is_", _PyCFunction_CAST(_operator_is_), METH_FASTCALL, _operator_is___doc__},
1347
1348 static PyObject *
1349 _operator_is__impl(PyObject *module, PyObject *a, PyObject *b);
1350
1351 static PyObject *
1352 _operator_is_(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1353 {
1354 PyObject *return_value = NULL;
1355 PyObject *a;
1356 PyObject *b;
1357
1358 if (!_PyArg_CheckPositional("is_", nargs, 2, 2)) {
1359 goto exit;
1360 }
1361 a = args[0];
1362 b = args[1];
1363 return_value = _operator_is__impl(module, a, b);
1364
1365 exit:
1366 return return_value;
1367 }
1368
1369 PyDoc_STRVAR(_operator_is_not__doc__,
1370 "is_not($module, a, b, /)\n"
1371 "--\n"
1372 "\n"
1373 "Same as a is not b.");
1374
1375 #define _OPERATOR_IS_NOT_METHODDEF \
1376 {"is_not", _PyCFunction_CAST(_operator_is_not), METH_FASTCALL, _operator_is_not__doc__},
1377
1378 static PyObject *
1379 _operator_is_not_impl(PyObject *module, PyObject *a, PyObject *b);
1380
1381 static PyObject *
1382 _operator_is_not(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1383 {
1384 PyObject *return_value = NULL;
1385 PyObject *a;
1386 PyObject *b;
1387
1388 if (!_PyArg_CheckPositional("is_not", nargs, 2, 2)) {
1389 goto exit;
1390 }
1391 a = args[0];
1392 b = args[1];
1393 return_value = _operator_is_not_impl(module, a, b);
1394
1395 exit:
1396 return return_value;
1397 }
1398
1399 PyDoc_STRVAR(_operator_length_hint__doc__,
1400 "length_hint($module, obj, default=0, /)\n"
1401 "--\n"
1402 "\n"
1403 "Return an estimate of the number of items in obj.\n"
1404 "\n"
1405 "This is useful for presizing containers when building from an iterable.\n"
1406 "\n"
1407 "If the object supports len(), the result will be exact.\n"
1408 "Otherwise, it may over- or under-estimate by an arbitrary amount.\n"
1409 "The result will be an integer >= 0.");
1410
1411 #define _OPERATOR_LENGTH_HINT_METHODDEF \
1412 {"length_hint", _PyCFunction_CAST(_operator_length_hint), METH_FASTCALL, _operator_length_hint__doc__},
1413
1414 static Py_ssize_t
1415 _operator_length_hint_impl(PyObject *module, PyObject *obj,
1416 Py_ssize_t default_value);
1417
1418 static PyObject *
1419 _operator_length_hint(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1420 {
1421 PyObject *return_value = NULL;
1422 PyObject *obj;
1423 Py_ssize_t default_value = 0;
1424 Py_ssize_t _return_value;
1425
1426 if (!_PyArg_CheckPositional("length_hint", nargs, 1, 2)) {
1427 goto exit;
1428 }
1429 obj = args[0];
1430 if (nargs < 2) {
1431 goto skip_optional;
1432 }
1433 {
1434 Py_ssize_t ival = -1;
1435 PyObject *iobj = _PyNumber_Index(args[1]);
1436 if (iobj != NULL) {
1437 ival = PyLong_AsSsize_t(iobj);
1438 Py_DECREF(iobj);
1439 }
1440 if (ival == -1 && PyErr_Occurred()) {
1441 goto exit;
1442 }
1443 default_value = ival;
1444 }
1445 skip_optional:
1446 _return_value = _operator_length_hint_impl(module, obj, default_value);
1447 if ((_return_value == -1) && PyErr_Occurred()) {
1448 goto exit;
1449 }
1450 return_value = PyLong_FromSsize_t(_return_value);
1451
1452 exit:
1453 return return_value;
1454 }
1455
1456 PyDoc_STRVAR(_operator__compare_digest__doc__,
1457 "_compare_digest($module, a, b, /)\n"
1458 "--\n"
1459 "\n"
1460 "Return \'a == b\'.\n"
1461 "\n"
1462 "This function uses an approach designed to prevent\n"
1463 "timing analysis, making it appropriate for cryptography.\n"
1464 "\n"
1465 "a and b must both be of the same type: either str (ASCII only),\n"
1466 "or any bytes-like object.\n"
1467 "\n"
1468 "Note: If a and b are of different lengths, or if an error occurs,\n"
1469 "a timing attack could theoretically reveal information about the\n"
1470 "types and lengths of a and b--but not their values.");
1471
1472 #define _OPERATOR__COMPARE_DIGEST_METHODDEF \
1473 {"_compare_digest", _PyCFunction_CAST(_operator__compare_digest), METH_FASTCALL, _operator__compare_digest__doc__},
1474
1475 static PyObject *
1476 _operator__compare_digest_impl(PyObject *module, PyObject *a, PyObject *b);
1477
1478 static PyObject *
1479 _operator__compare_digest(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1480 {
1481 PyObject *return_value = NULL;
1482 PyObject *a;
1483 PyObject *b;
1484
1485 if (!_PyArg_CheckPositional("_compare_digest", nargs, 2, 2)) {
1486 goto exit;
1487 }
1488 a = args[0];
1489 b = args[1];
1490 return_value = _operator__compare_digest_impl(module, a, b);
1491
1492 exit:
1493 return return_value;
1494 }
1495 /*[clinic end generated code: output=227cbcfed44f736e input=a9049054013a1b77]*/