LCOV - code coverage report
Current view: | top level - Modules/clinic - itertoolsmodule.c.h (source / functions) |  |  | Hit | Total | Coverage
Test: | CPython 3.12 LCOV report [commit 5e6661bce9] |  | Lines: | 32 | 282 | 11.3 %
Date: | 2023-03-20 08:15:36 |  | Functions: | 2 | 18 | 11.1 %
|  |  | Branches: | 17 | 268 | 6.3 %

               Branch data     Line data    Source code
           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(batched_new__doc__,
          12                 :            : "batched(iterable, n)\n"
          13                 :            : "--\n"
          14                 :            : "\n"
          15                 :            : "Batch data into tuples of length n. The last batch may be shorter than n.\n"
          16                 :            : "\n"
          17                 :            : "Loops over the input iterable and accumulates data into tuples\n"
          18                 :            : "up to size n.  The input is consumed lazily, just enough to\n"
          19                 :            : "fill a batch.  The result is yielded as soon as a batch is full\n"
          20                 :            : "or when the input iterable is exhausted.\n"
          21                 :            : "\n"
          22                 :            : "    >>> for batch in batched(\'ABCDEFG\', 3):\n"
          23                 :            : "    ...     print(batch)\n"
          24                 :            : "    ...\n"
          25                 :            : "    (\'A\', \'B\', \'C\')\n"
          26                 :            : "    (\'D\', \'E\', \'F\')\n"
          27                 :            : "    (\'G\',)");
          28                 :            :
          29                 :            : static PyObject *
          30                 :            : batched_new_impl(PyTypeObject *type, PyObject *iterable, Py_ssize_t n);
          31                 :            :
          32                 :            : static PyObject *
          33                 :          0 : batched_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
          34                 :            : {
          35                 :          0 :     PyObject *return_value = NULL;
          36                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
          37                 :            :
          38                 :            :     #define NUM_KEYWORDS 2
          39                 :            :     static struct {
          40                 :            :         PyGC_Head _this_is_not_used;
          41                 :            :         PyObject_VAR_HEAD
          42                 :            :         PyObject *ob_item[NUM_KEYWORDS];
          43                 :            :     } _kwtuple = {
          44                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
          45                 :            :         .ob_item = { &_Py_ID(iterable), &_Py_ID(n), },
          46                 :            :     };
          47                 :            :     #undef NUM_KEYWORDS
          48                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
          49                 :            :
          50                 :            :     #else  // !Py_BUILD_CORE
          51                 :            :     #  define KWTUPLE NULL
          52                 :            :     #endif  // !Py_BUILD_CORE
          53                 :            :
          54                 :            :     static const char * const _keywords[] = {"iterable", "n", NULL};
          55                 :            :     static _PyArg_Parser _parser = {
          56                 :            :         .keywords = _keywords,
          57                 :            :         .fname = "batched",
          58                 :            :         .kwtuple = KWTUPLE,
          59                 :            :     };
          60                 :            :     #undef KWTUPLE
          61                 :            :     PyObject *argsbuf[2];
          62                 :            :     PyObject * const *fastargs;
          63                 :          0 :     Py_ssize_t nargs = PyTuple_GET_SIZE(args);
          64                 :            :     PyObject *iterable;
          65                 :            :     Py_ssize_t n;
          66                 :            :
          67   [ #  #  #  #  :          0 :     fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, 2, 2, 0, argsbuf);
                 #  #  #  # ]
          68         [ #  # ]:          0 :     if (!fastargs) {
          69                 :          0 :         goto exit;
          70                 :            :     }
          71                 :          0 :     iterable = fastargs[0];
          72                 :            :     {
          73                 :          0 :         Py_ssize_t ival = -1;
          74                 :          0 :         PyObject *iobj = _PyNumber_Index(fastargs[1]);
          75         [ #  # ]:          0 :         if (iobj != NULL) {
          76                 :          0 :             ival = PyLong_AsSsize_t(iobj);
          77                 :          0 :             Py_DECREF(iobj);
          78                 :            :         }
          79   [ #  #  #  # ]:          0 :         if (ival == -1 && PyErr_Occurred()) {
          80                 :          0 :             goto exit;
          81                 :            :         }
          82                 :          0 :         n = ival;
          83                 :            :     }
          84                 :          0 :     return_value = batched_new_impl(type, iterable, n);
          85                 :            :
          86                 :          0 : exit:
          87                 :          0 :     return return_value;
          88                 :            : }
          89                 :            :
          90                 :            : PyDoc_STRVAR(pairwise_new__doc__,
          91                 :            : "pairwise(iterable, /)\n"
          92                 :            : "--\n"
          93                 :            : "\n"
          94                 :            : "Return an iterator of overlapping pairs taken from the input iterator.\n"
          95                 :            : "\n"
          96                 :            : "    s -> (s0,s1), (s1,s2), (s2, s3), ...");
          97                 :            :
          98                 :            : static PyObject *
          99                 :            : pairwise_new_impl(PyTypeObject *type, PyObject *iterable);
         100                 :            :
         101                 :            : static PyObject *
         102                 :          0 : pairwise_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
         103                 :            : {
         104                 :          0 :     PyObject *return_value = NULL;
         105                 :          0 :     PyTypeObject *base_tp = clinic_state()->pairwise_type;
         106                 :            :     PyObject *iterable;
         107                 :            :
         108   [ #  #  #  #  :          0 :     if ((type == base_tp || type->tp_init == base_tp->tp_init) &&
                       #  # ]
         109         [ #  # ]:          0 :         !_PyArg_NoKeywords("pairwise", kwargs)) {
         110                 :          0 :         goto exit;
         111                 :            :     }
         112   [ #  #  #  #  :          0 :     if (!_PyArg_CheckPositional("pairwise", PyTuple_GET_SIZE(args), 1, 1)) {
                       #  # ]
         113                 :          0 :         goto exit;
         114                 :            :     }
         115                 :          0 :     iterable = PyTuple_GET_ITEM(args, 0);
         116                 :          0 :     return_value = pairwise_new_impl(type, iterable);
         117                 :            :
         118                 :          0 : exit:
         119                 :          0 :     return return_value;
         120                 :            : }
         121                 :            :
         122                 :            : PyDoc_STRVAR(itertools_groupby__doc__,
         123                 :            : "groupby(iterable, key=None)\n"
         124                 :            : "--\n"
         125                 :            : "\n"
         126                 :            : "make an iterator that returns consecutive keys and groups from the iterable\n"
         127                 :            : "\n"
         128                 :            : "  iterable\n"
         129                 :            : "    Elements to divide into groups according to the key function.\n"
         130                 :            : "  key\n"
         131                 :            : "    A function for computing the group category for each element.\n"
         132                 :            : "    If the key function is not specified or is None, the element itself\n"
         133                 :            : "    is used for grouping.");
         134                 :            :
         135                 :            : static PyObject *
         136                 :            : itertools_groupby_impl(PyTypeObject *type, PyObject *it, PyObject *keyfunc);
         137                 :            :
         138                 :            : static PyObject *
         139                 :          0 : itertools_groupby(PyTypeObject *type, PyObject *args, PyObject *kwargs)
         140                 :            : {
         141                 :          0 :     PyObject *return_value = NULL;
         142                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
         143                 :            :
         144                 :            :     #define NUM_KEYWORDS 2
         145                 :            :     static struct {
         146                 :            :         PyGC_Head _this_is_not_used;
         147                 :            :         PyObject_VAR_HEAD
         148                 :            :         PyObject *ob_item[NUM_KEYWORDS];
         149                 :            :     } _kwtuple = {
         150                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
         151                 :            :         .ob_item = { &_Py_ID(iterable), &_Py_ID(key), },
         152                 :            :     };
         153                 :            :     #undef NUM_KEYWORDS
         154                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
         155                 :            :
         156                 :            :     #else  // !Py_BUILD_CORE
         157                 :            :     #  define KWTUPLE NULL
         158                 :            :     #endif  // !Py_BUILD_CORE
         159                 :            :
         160                 :            :     static const char * const _keywords[] = {"iterable", "key", NULL};
         161                 :            :     static _PyArg_Parser _parser = {
         162                 :            :         .keywords = _keywords,
         163                 :            :         .fname = "groupby",
         164                 :            :         .kwtuple = KWTUPLE,
         165                 :            :     };
         166                 :            :     #undef KWTUPLE
         167                 :            :     PyObject *argsbuf[2];
         168                 :            :     PyObject * const *fastargs;
         169                 :          0 :     Py_ssize_t nargs = PyTuple_GET_SIZE(args);
         170         [ #  # ]:          0 :     Py_ssize_t noptargs = nargs + (kwargs ? PyDict_GET_SIZE(kwargs) : 0) - 1;
         171                 :            :     PyObject *it;
         172                 :          0 :     PyObject *keyfunc = Py_None;
         173                 :            :
         174   [ #  #  #  #  :          0 :     fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, 1, 2, 0, argsbuf);
                 #  #  #  # ]
         175         [ #  # ]:          0 :     if (!fastargs) {
         176                 :          0 :         goto exit;
         177                 :            :     }
         178                 :          0 :     it = fastargs[0];
         179         [ #  # ]:          0 :     if (!noptargs) {
         180                 :          0 :         goto skip_optional_pos;
         181                 :            :     }
         182                 :          0 :     keyfunc = fastargs[1];
         183                 :          0 : skip_optional_pos:
         184                 :          0 :     return_value = itertools_groupby_impl(type, it, keyfunc);
         185                 :            :
         186                 :          0 : exit:
         187                 :          0 :     return return_value;
         188                 :            : }
         189                 :            :
         190                 :            : static PyObject *
         191                 :            : itertools__grouper_impl(PyTypeObject *type, PyObject *parent,
         192                 :            :                         PyObject *tgtkey);
         193                 :            :
         194                 :            : static PyObject *
         195                 :          0 : itertools__grouper(PyTypeObject *type, PyObject *args, PyObject *kwargs)
         196                 :            : {
         197                 :          0 :     PyObject *return_value = NULL;
         198                 :          0 :     PyTypeObject *base_tp = clinic_state()->_grouper_type;
         199                 :            :     PyObject *parent;
         200                 :            :     PyObject *tgtkey;
         201                 :            :
         202   [ #  #  #  #  :          0 :     if ((type == base_tp || type->tp_init == base_tp->tp_init) &&
                       #  # ]
         203         [ #  # ]:          0 :         !_PyArg_NoKeywords("_grouper", kwargs)) {
         204                 :          0 :         goto exit;
         205                 :            :     }
         206   [ #  #  #  #  :          0 :     if (!_PyArg_CheckPositional("_grouper", PyTuple_GET_SIZE(args), 2, 2)) {
                       #  # ]
         207                 :          0 :         goto exit;
         208                 :            :     }
         209         [ #  # ]:          0 :     if (!PyObject_TypeCheck(PyTuple_GET_ITEM(args, 0), clinic_state_by_cls()->groupby_type)) {
         210                 :          0 :         _PyArg_BadArgument("_grouper", "argument 1", (clinic_state_by_cls()->groupby_type)->tp_name, PyTuple_GET_ITEM(args, 0));
         211                 :          0 :         goto exit;
         212                 :            :     }
         213                 :          0 :     parent = PyTuple_GET_ITEM(args, 0);
         214                 :          0 :     tgtkey = PyTuple_GET_ITEM(args, 1);
         215                 :          0 :     return_value = itertools__grouper_impl(type, parent, tgtkey);
         216                 :            :
         217                 :          0 : exit:
         218                 :          0 :     return return_value;
         219                 :            : }
         220                 :            :
         221                 :            : PyDoc_STRVAR(itertools_teedataobject__doc__,
         222                 :            : "teedataobject(iterable, values, next, /)\n"
         223                 :            : "--\n"
         224                 :            : "\n"
         225                 :            : "Data container common to multiple tee objects.");
         226                 :            :
         227                 :            : static PyObject *
         228                 :            : itertools_teedataobject_impl(PyTypeObject *type, PyObject *it,
         229                 :            :                              PyObject *values, PyObject *next);
         230                 :            :
         231                 :            : static PyObject *
         232                 :          0 : itertools_teedataobject(PyTypeObject *type, PyObject *args, PyObject *kwargs)
         233                 :            : {
         234                 :          0 :     PyObject *return_value = NULL;
         235                 :          0 :     PyTypeObject *base_tp = clinic_state()->teedataobject_type;
         236                 :            :     PyObject *it;
         237                 :            :     PyObject *values;
         238                 :            :     PyObject *next;
         239                 :            :
         240   [ #  #  #  #  :          0 :     if ((type == base_tp || type->tp_init == base_tp->tp_init) &&
                       #  # ]
         241         [ #  # ]:          0 :         !_PyArg_NoKeywords("teedataobject", kwargs)) {
         242                 :          0 :         goto exit;
         243                 :            :     }
         244   [ #  #  #  #  :          0 :     if (!_PyArg_CheckPositional("teedataobject", PyTuple_GET_SIZE(args), 3, 3)) {
                       #  # ]
         245                 :          0 :         goto exit;
         246                 :            :     }
         247                 :          0 :     it = PyTuple_GET_ITEM(args, 0);
         248         [ #  # ]:          0 :     if (!PyList_Check(PyTuple_GET_ITEM(args, 1))) {
         249                 :          0 :         _PyArg_BadArgument("teedataobject", "argument 2", "list", PyTuple_GET_ITEM(args, 1));
         250                 :          0 :         goto exit;
         251                 :            :     }
         252                 :          0 :     values = PyTuple_GET_ITEM(args, 1);
         253                 :          0 :     next = PyTuple_GET_ITEM(args, 2);
         254                 :          0 :     return_value = itertools_teedataobject_impl(type, it, values, next);
         255                 :            :
         256                 :          0 : exit:
         257                 :          0 :     return return_value;
         258                 :            : }
         259                 :            :
         260                 :            : PyDoc_STRVAR(itertools__tee__doc__,
         261                 :            : "_tee(iterable, /)\n"
         262                 :            : "--\n"
         263                 :            : "\n"
         264                 :            : "Iterator wrapped to make it copyable.");
         265                 :            :
         266                 :            : static PyObject *
         267                 :            : itertools__tee_impl(PyTypeObject *type, PyObject *iterable);
         268                 :            :
         269                 :            : static PyObject *
         270                 :          0 : itertools__tee(PyTypeObject *type, PyObject *args, PyObject *kwargs)
         271                 :            : {
         272                 :          0 :     PyObject *return_value = NULL;
         273                 :          0 :     PyTypeObject *base_tp = clinic_state()->tee_type;
         274                 :            :     PyObject *iterable;
         275                 :            :
         276   [ #  #  #  #  :          0 :     if ((type == base_tp || type->tp_init == base_tp->tp_init) &&
                       #  # ]
         277         [ #  # ]:          0 :         !_PyArg_NoKeywords("_tee", kwargs)) {
         278                 :          0 :         goto exit;
         279                 :            :     }
         280   [ #  #  #  #  :          0 :     if (!_PyArg_CheckPositional("_tee", PyTuple_GET_SIZE(args), 1, 1)) {
                       #  # ]
         281                 :          0 :         goto exit;
         282                 :            :     }
         283                 :          0 :     iterable = PyTuple_GET_ITEM(args, 0);
         284                 :          0 :     return_value = itertools__tee_impl(type, iterable);
         285                 :            :
         286                 :          0 : exit:
         287                 :          0 :     return return_value;
         288                 :            : }
         289                 :            :
         290                 :            : PyDoc_STRVAR(itertools_tee__doc__,
         291                 :            : "tee($module, iterable, n=2, /)\n"
         292                 :            : "--\n"
         293                 :            : "\n"
         294                 :            : "Returns a tuple of n independent iterators.");
         295                 :            :
         296                 :            : #define ITERTOOLS_TEE_METHODDEF    \
         297                 :            :     {"tee", _PyCFunction_CAST(itertools_tee), METH_FASTCALL, itertools_tee__doc__},
         298                 :            :
         299                 :            : static PyObject *
         300                 :            : itertools_tee_impl(PyObject *module, PyObject *iterable, Py_ssize_t n);
         301                 :            :
         302                 :            : static PyObject *
         303                 :          0 : itertools_tee(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
         304                 :            : {
         305                 :          0 :     PyObject *return_value = NULL;
         306                 :            :     PyObject *iterable;
         307                 :          0 :     Py_ssize_t n = 2;
         308                 :            :
         309   [ #  #  #  #  :          0 :     if (!_PyArg_CheckPositional("tee", nargs, 1, 2)) {
                       #  # ]
         310                 :          0 :         goto exit;
         311                 :            :     }
         312                 :          0 :     iterable = args[0];
         313         [ #  # ]:          0 :     if (nargs < 2) {
         314                 :          0 :         goto skip_optional;
         315                 :            :     }
         316                 :            :     {
         317                 :          0 :         Py_ssize_t ival = -1;
         318                 :          0 :         PyObject *iobj = _PyNumber_Index(args[1]);
         319         [ #  # ]:          0 :         if (iobj != NULL) {
         320                 :          0 :             ival = PyLong_AsSsize_t(iobj);
         321                 :          0 :             Py_DECREF(iobj);
         322                 :            :         }
         323   [ #  #  #  # ]:          0 :         if (ival == -1 && PyErr_Occurred()) {
         324                 :          0 :             goto exit;
         325                 :            :         }
         326                 :          0 :         n = ival;
         327                 :            :     }
         328                 :          0 : skip_optional:
         329                 :          0 :     return_value = itertools_tee_impl(module, iterable, n);
         330                 :            :
         331                 :          0 : exit:
         332                 :          0 :     return return_value;
         333                 :            : }
         334                 :            :
         335                 :            : PyDoc_STRVAR(itertools_cycle__doc__,
         336                 :            : "cycle(iterable, /)\n"
         337                 :            : "--\n"
         338                 :            : "\n"
         339                 :            : "Return elements from the iterable until it is exhausted. Then repeat the sequence indefinitely.");
         340                 :            :
         341                 :            : static PyObject *
         342                 :            : itertools_cycle_impl(PyTypeObject *type, PyObject *iterable);
         343                 :            :
         344                 :            : static PyObject *
         345                 :          0 : itertools_cycle(PyTypeObject *type, PyObject *args, PyObject *kwargs)
         346                 :            : {
         347                 :          0 :     PyObject *return_value = NULL;
         348                 :          0 :     PyTypeObject *base_tp = clinic_state()->cycle_type;
         349                 :            :     PyObject *iterable;
         350                 :            :
         351   [ #  #  #  #  :          0 :     if ((type == base_tp || type->tp_init == base_tp->tp_init) &&
                       #  # ]
         352         [ #  # ]:          0 :         !_PyArg_NoKeywords("cycle", kwargs)) {
         353                 :          0 :         goto exit;
         354                 :            :     }
         355   [ #  #  #  #  :          0 :     if (!_PyArg_CheckPositional("cycle", PyTuple_GET_SIZE(args), 1, 1)) {
                       #  # ]
         356                 :          0 :         goto exit;
         357                 :            :     }
         358                 :          0 :     iterable = PyTuple_GET_ITEM(args, 0);
         359                 :          0 :     return_value = itertools_cycle_impl(type, iterable);
         360                 :            :
         361                 :          0 : exit:
         362                 :          0 :     return return_value;
         363                 :            : }
         364                 :            :
         365                 :            : PyDoc_STRVAR(itertools_dropwhile__doc__,
         366                 :            : "dropwhile(predicate, iterable, /)\n"
         367                 :            : "--\n"
         368                 :            : "\n"
         369                 :            : "Drop items from the iterable while predicate(item) is true.\n"
         370                 :            : "\n"
         371                 :            : "Afterwards, return every element until the iterable is exhausted.");
         372                 :            :
         373                 :            : static PyObject *
         374                 :            : itertools_dropwhile_impl(PyTypeObject *type, PyObject *func, PyObject *seq);
         375                 :            :
         376                 :            : static PyObject *
         377                 :          0 : itertools_dropwhile(PyTypeObject *type, PyObject *args, PyObject *kwargs)
         378                 :            : {
         379                 :          0 :     PyObject *return_value = NULL;
         380                 :          0 :     PyTypeObject *base_tp = clinic_state()->dropwhile_type;
         381                 :            :     PyObject *func;
         382                 :            :     PyObject *seq;
         383                 :            :
         384   [ #  #  #  #  :          0 :     if ((type == base_tp || type->tp_init == base_tp->tp_init) &&
                       #  # ]
         385         [ #  # ]:          0 :         !_PyArg_NoKeywords("dropwhile", kwargs)) {
         386                 :          0 :         goto exit;
         387                 :            :     }
         388   [ #  #  #  #  :          0 :     if (!_PyArg_CheckPositional("dropwhile", PyTuple_GET_SIZE(args), 2, 2)) {
                       #  # ]
         389                 :          0 :         goto exit;
         390                 :            :     }
         391                 :          0 :     func = PyTuple_GET_ITEM(args, 0);
         392                 :          0 :     seq = PyTuple_GET_ITEM(args, 1);
         393                 :          0 :     return_value = itertools_dropwhile_impl(type, func, seq);
         394                 :            :
         395                 :          0 : exit:
         396                 :          0 :     return return_value;
         397                 :            : }
         398                 :            :
         399                 :            : PyDoc_STRVAR(itertools_takewhile__doc__,
         400                 :            : "takewhile(predicate, iterable, /)\n"
         401                 :            : "--\n"
         402                 :            : "\n"
         403                 :            : "Return successive entries from an iterable as long as the predicate evaluates to true for each entry.");
         404                 :            :
         405                 :            : static PyObject *
         406                 :            : itertools_takewhile_impl(PyTypeObject *type, PyObject *func, PyObject *seq);
         407                 :            :
         408                 :            : static PyObject *
         409                 :          0 : itertools_takewhile(PyTypeObject *type, PyObject *args, PyObject *kwargs)
         410                 :            : {
         411                 :          0 :     PyObject *return_value = NULL;
         412                 :          0 :     PyTypeObject *base_tp = clinic_state()->takewhile_type;
         413                 :            :     PyObject *func;
         414                 :            :     PyObject *seq;
         415                 :            :
         416   [ #  #  #  #  :          0 :     if ((type == base_tp || type->tp_init == base_tp->tp_init) &&
                       #  # ]
         417         [ #  # ]:          0 :         !_PyArg_NoKeywords("takewhile", kwargs)) {
         418                 :          0 :         goto exit;
         419                 :            :     }
         420   [ #  #  #  #  :          0 :     if (!_PyArg_CheckPositional("takewhile", PyTuple_GET_SIZE(args), 2, 2)) {
                       #  # ]
         421                 :          0 :         goto exit;
         422                 :            :     }
         423                 :          0 :     func = PyTuple_GET_ITEM(args, 0);
         424                 :          0 :     seq = PyTuple_GET_ITEM(args, 1);
         425                 :          0 :     return_value = itertools_takewhile_impl(type, func, seq);
         426                 :            :
         427                 :          0 : exit:
         428                 :          0 :     return return_value;
         429                 :            : }
         430                 :            :
         431                 :            : PyDoc_STRVAR(itertools_starmap__doc__,
         432                 :            : "starmap(function, iterable, /)\n"
         433                 :            : "--\n"
         434                 :            : "\n"
         435                 :            : "Return an iterator whose values are returned from the function evaluated with an argument tuple taken from the given sequence.");
         436                 :            :
         437                 :            : static PyObject *
         438                 :            : itertools_starmap_impl(PyTypeObject *type, PyObject *func, PyObject *seq);
         439                 :            :
         440                 :            : static PyObject *
         441                 :          0 : itertools_starmap(PyTypeObject *type, PyObject *args, PyObject *kwargs)
         442                 :            : {
         443                 :          0 :     PyObject *return_value = NULL;
         444                 :          0 :     PyTypeObject *base_tp = clinic_state()->starmap_type;
         445                 :            :     PyObject *func;
         446                 :            :     PyObject *seq;
         447                 :            :
         448   [ #  #  #  #  :          0 :     if ((type == base_tp || type->tp_init == base_tp->tp_init) &&
                       #  # ]
         449         [ #  # ]:          0 :         !_PyArg_NoKeywords("starmap", kwargs)) {
         450                 :          0 :         goto exit;
         451                 :            :     }
         452   [ #  #  #  #  :          0 :     if (!_PyArg_CheckPositional("starmap", PyTuple_GET_SIZE(args), 2, 2)) {
                       #  # ]
         453                 :          0 :         goto exit;
         454                 :            :     }
         455                 :          0 :     func = PyTuple_GET_ITEM(args, 0);
         456                 :          0 :     seq = PyTuple_GET_ITEM(args, 1);
         457                 :          0 :     return_value = itertools_starmap_impl(type, func, seq);
         458                 :            :
         459                 :          0 : exit:
         460                 :          0 :     return return_value;
         461                 :            : }
         462                 :            :
         463                 :            : PyDoc_STRVAR(itertools_chain_from_iterable__doc__,
         464                 :            : "from_iterable($type, iterable, /)\n"
         465                 :            : "--\n"
         466                 :            : "\n"
         467                 :            : "Alternative chain() constructor taking a single iterable argument that evaluates lazily.");
         468                 :            :
         469                 :            : #define ITERTOOLS_CHAIN_FROM_ITERABLE_METHODDEF    \
         470                 :            :     {"from_iterable", (PyCFunction)itertools_chain_from_iterable, METH_O|METH_CLASS, itertools_chain_from_iterable__doc__},
         471                 :            :
         472                 :            : PyDoc_STRVAR(itertools_combinations__doc__,
         473                 :            : "combinations(iterable, r)\n"
         474                 :            : "--\n"
         475                 :            : "\n"
         476                 :            : "Return successive r-length combinations of elements in the iterable.\n"
         477                 :            : "\n"
         478                 :            : "combinations(range(4), 3) --> (0,1,2), (0,1,3), (0,2,3), (1,2,3)");
         479                 :            :
         480                 :            : static PyObject *
         481                 :            : itertools_combinations_impl(PyTypeObject *type, PyObject *iterable,
         482                 :            :                             Py_ssize_t r);
         483                 :            :
         484                 :            : static PyObject *
         485                 :          0 : itertools_combinations(PyTypeObject *type, PyObject *args, PyObject *kwargs)
         486                 :            : {
         487                 :          0 :     PyObject *return_value = NULL;
         488                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
         489                 :            :
         490                 :            :     #define NUM_KEYWORDS 2
         491                 :            :     static struct {
         492                 :            :         PyGC_Head _this_is_not_used;
         493                 :            :         PyObject_VAR_HEAD
         494                 :            :         PyObject *ob_item[NUM_KEYWORDS];
         495                 :            :     } _kwtuple = {
         496                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
         497                 :            :         .ob_item = { &_Py_ID(iterable), &_Py_ID(r), },
         498                 :            :     };
         499                 :            :     #undef NUM_KEYWORDS
         500                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
         501                 :            :
         502                 :            :     #else  // !Py_BUILD_CORE
         503                 :            :     #  define KWTUPLE NULL
         504                 :            :     #endif  // !Py_BUILD_CORE
         505                 :            :
         506                 :            :     static const char * const _keywords[] = {"iterable", "r", NULL};
         507                 :            :     static _PyArg_Parser _parser = {
         508                 :            :         .keywords = _keywords,
         509                 :            :         .fname = "combinations",
         510                 :            :         .kwtuple = KWTUPLE,
         511                 :            :     };
         512                 :            :     #undef KWTUPLE
         513                 :            :     PyObject *argsbuf[2];
         514                 :            :     PyObject * const *fastargs;
         515                 :          0 :     Py_ssize_t nargs = PyTuple_GET_SIZE(args);
         516                 :            :     PyObject *iterable;
         517                 :            :     Py_ssize_t r;
         518                 :            :
         519   [ #  #  #  #  :          0 :     fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, 2, 2, 0, argsbuf);
                 #  #  #  # ]
         520         [ #  # ]:          0 :     if (!fastargs) {
         521                 :          0 :         goto exit;
         522                 :            :     }
         523                 :          0 :     iterable = fastargs[0];
         524                 :            :     {
         525                 :          0 :         Py_ssize_t ival = -1;
         526                 :          0 :         PyObject *iobj = _PyNumber_Index(fastargs[1]);
         527         [ #  # ]:          0 :         if (iobj != NULL) {
         528                 :          0 :             ival = PyLong_AsSsize_t(iobj);
         529                 :          0 :             Py_DECREF(iobj);
         530                 :            :         }
         531   [ #  #  #  # ]:          0 :         if (ival == -1 && PyErr_Occurred()) {
         532                 :          0 :             goto exit;
         533                 :            :         }
         534                 :          0 :         r = ival;
         535                 :            :     }
         536                 :          0 :     return_value = itertools_combinations_impl(type, iterable, r);
         537                 :            :
         538                 :          0 : exit:
         539                 :          0 :     return return_value;
         540                 :            : }
         541                 :            :
         542                 :            : PyDoc_STRVAR(itertools_combinations_with_replacement__doc__,
         543                 :            : "combinations_with_replacement(iterable, r)\n"
         544                 :            : "--\n"
         545                 :            : "\n"
         546                 :            : "Return successive r-length combinations of elements in the iterable allowing individual elements to have successive repeats.\n"
         547                 :            : "\n"
         548                 :            : "combinations_with_replacement(\'ABC\', 2) --> (\'A\',\'A\'), (\'A\',\'B\'), (\'A\',\'C\'), (\'B\',\'B\'), (\'B\',\'C\'), (\'C\',\'C\')");
         549                 :            :
         550                 :            : static PyObject *
         551                 :            : itertools_combinations_with_replacement_impl(PyTypeObject *type,
         552                 :            :                                              PyObject *iterable,
         553                 :            :                                              Py_ssize_t r);
         554                 :            :
         555                 :            : static PyObject *
         556                 :          0 : itertools_combinations_with_replacement(PyTypeObject *type, PyObject *args, PyObject *kwargs)
         557                 :            : {
         558                 :          0 :     PyObject *return_value = NULL;
         559                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
         560                 :            :
         561                 :            :     #define NUM_KEYWORDS 2
         562                 :            :     static struct {
         563                 :            :         PyGC_Head _this_is_not_used;
         564                 :            :         PyObject_VAR_HEAD
         565                 :            :         PyObject *ob_item[NUM_KEYWORDS];
         566                 :            :     } _kwtuple = {
         567                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
         568                 :            :         .ob_item = { &_Py_ID(iterable), &_Py_ID(r), },
         569                 :            :     };
         570                 :            :     #undef NUM_KEYWORDS
         571                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
         572                 :            :
         573                 :            :     #else  // !Py_BUILD_CORE
         574                 :            :     #  define KWTUPLE NULL
         575                 :            :     #endif  // !Py_BUILD_CORE
         576                 :            :
         577                 :            :     static const char * const _keywords[] = {"iterable", "r", NULL};
         578                 :            :     static _PyArg_Parser _parser = {
         579                 :            :         .keywords = _keywords,
         580                 :            :         .fname = "combinations_with_replacement",
         581                 :            :         .kwtuple = KWTUPLE,
         582                 :            :     };
         583                 :            :     #undef KWTUPLE
         584                 :            :     PyObject *argsbuf[2];
         585                 :            :     PyObject * const *fastargs;
         586                 :          0 :     Py_ssize_t nargs = PyTuple_GET_SIZE(args);
         587                 :            :     PyObject *iterable;
         588                 :            :     Py_ssize_t r;
         589                 :            :
         590   [ #  #  #  #  :          0 :     fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, 2, 2, 0, argsbuf);
                 #  #  #  # ]
         591         [ #  # ]:          0 :     if (!fastargs) {
         592                 :          0 :         goto exit;
         593                 :            :     }
         594                 :          0 :     iterable = fastargs[0];
         595                 :            :     {
         596                 :          0 :         Py_ssize_t ival = -1;
         597                 :          0 :         PyObject *iobj = _PyNumber_Index(fastargs[1]);
         598         [ #  # ]:          0 :         if (iobj != NULL) {
         599                 :          0 :             ival = PyLong_AsSsize_t(iobj);
         600                 :          0 :             Py_DECREF(iobj);
         601                 :            :         }
         602   [ #  #  #  # ]:          0 :         if (ival == -1 && PyErr_Occurred()) {
         603                 :          0 :             goto exit;
         604                 :            :         }
         605                 :          0 :         r = ival;
         606                 :            :     }
         607                 :          0 :     return_value = itertools_combinations_with_replacement_impl(type, iterable, r);
         608                 :            :
         609                 :          0 : exit:
         610                 :          0 :     return return_value;
         611                 :            : }
         612                 :            :
         613                 :            : PyDoc_STRVAR(itertools_permutations__doc__,
         614                 :            : "permutations(iterable, r=None)\n"
         615                 :            : "--\n"
         616                 :            : "\n"
         617                 :            : "Return successive r-length permutations of elements in the iterable.\n"
         618                 :            : "\n"
         619                 :            : "permutations(range(3), 2) --> (0,1), (0,2), (1,0), (1,2), (2,0), (2,1)");
         620                 :            :
         621                 :            : static PyObject *
         622                 :            : itertools_permutations_impl(PyTypeObject *type, PyObject *iterable,
         623                 :            :                             PyObject *robj);
         624                 :            :
         625                 :            : static PyObject *
         626                 :         54 : itertools_permutations(PyTypeObject *type, PyObject *args, PyObject *kwargs)
         627                 :            : {
         628                 :         54 :     PyObject *return_value = NULL;
         629                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
         630                 :            :
         631                 :            :     #define NUM_KEYWORDS 2
         632                 :            :     static struct {
         633                 :            :         PyGC_Head _this_is_not_used;
         634                 :            :         PyObject_VAR_HEAD
         635                 :            :         PyObject *ob_item[NUM_KEYWORDS];
         636                 :            :     } _kwtuple = {
         637                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
         638                 :            :         .ob_item = { &_Py_ID(iterable), &_Py_ID(r), },
         639                 :            :     };
         640                 :            :     #undef NUM_KEYWORDS
         641                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
         642                 :            :
         643                 :            :     #else  // !Py_BUILD_CORE
         644                 :            :     #  define KWTUPLE NULL
         645                 :            :     #endif  // !Py_BUILD_CORE
         646                 :            :
         647                 :            :     static const char * const _keywords[] = {"iterable", "r", NULL};
         648                 :            :     static _PyArg_Parser _parser = {
         649                 :            :         .keywords = _keywords,
         650                 :            :         .fname = "permutations",
         651                 :            :         .kwtuple = KWTUPLE,
         652                 :            :     };
         653                 :            :     #undef KWTUPLE
         654                 :            :     PyObject *argsbuf[2];
         655                 :            :     PyObject * const *fastargs;
         656                 :         54 :     Py_ssize_t nargs = PyTuple_GET_SIZE(args);
         657         [ -  + ]:         54 :     Py_ssize_t noptargs = nargs + (kwargs ? PyDict_GET_SIZE(kwargs) : 0) - 1;
         658                 :            :     PyObject *iterable;
         659                 :         54 :     PyObject *robj = Py_None;
         660                 :            :
         661   [ +  -  +  -  :         54 :     fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, 1, 2, 0, argsbuf);
                 +  -  +  - ]
         662         [ -  + ]:         54 :     if (!fastargs) {
         663                 :          0 :         goto exit;
         664                 :            :     }
         665                 :         54 :     iterable = fastargs[0];
         666         [ +  - ]:         54 :     if (!noptargs) {
         667                 :         54 :         goto skip_optional_pos;
         668                 :            :     }
         669                 :          0 :     robj = fastargs[1];
         670                 :         54 : skip_optional_pos:
         671                 :         54 :     return_value = itertools_permutations_impl(type, iterable, robj);
         672                 :            :
         673                 :         54 : exit:
         674                 :         54 :     return return_value;
         675                 :            : }
         676                 :            :
         677                 :            : PyDoc_STRVAR(itertools_accumulate__doc__,
         678                 :            : "accumulate(iterable, func=None, *, initial=None)\n"
         679                 :            : "--\n"
         680                 :            : "\n"
         681                 :            : "Return series of accumulated sums (or other binary function results).");
         682                 :            :
         683                 :            : static PyObject *
         684                 :            : itertools_accumulate_impl(PyTypeObject *type, PyObject *iterable,
         685                 :            :                           PyObject *binop, PyObject *initial);
         686                 :            :
         687                 :            : static PyObject *
         688                 :          0 : itertools_accumulate(PyTypeObject *type, PyObject *args, PyObject *kwargs)
         689                 :            : {
         690                 :          0 :     PyObject *return_value = NULL;
         691                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
         692                 :            :
         693                 :            :     #define NUM_KEYWORDS 3
         694                 :            :     static struct {
         695                 :            :         PyGC_Head _this_is_not_used;
         696                 :            :         PyObject_VAR_HEAD
         697                 :            :         PyObject *ob_item[NUM_KEYWORDS];
         698                 :            :     } _kwtuple = {
         699                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
         700                 :            :         .ob_item = { &_Py_ID(iterable), &_Py_ID(func), &_Py_ID(initial), },
         701                 :            :     };
         702                 :            :     #undef NUM_KEYWORDS
         703                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
         704                 :            :
         705                 :            :     #else  // !Py_BUILD_CORE
         706                 :            :     #  define KWTUPLE NULL
         707                 :            :     #endif  // !Py_BUILD_CORE
         708                 :            :
         709                 :            :     static const char * const _keywords[] = {"iterable", "func", "initial", NULL};
         710                 :            :     static _PyArg_Parser _parser = {
         711                 :            :         .keywords = _keywords,
         712                 :            :         .fname = "accumulate",
         713                 :            :         .kwtuple = KWTUPLE,
         714                 :            :     };
         715                 :            :     #undef KWTUPLE
         716                 :            :     PyObject *argsbuf[3];
         717                 :            :     PyObject * const *fastargs;
         718                 :          0 :     Py_ssize_t nargs = PyTuple_GET_SIZE(args);
         719         [ #  # ]:          0 :     Py_ssize_t noptargs = nargs + (kwargs ? PyDict_GET_SIZE(kwargs) : 0) - 1;
         720                 :            :     PyObject *iterable;
         721                 :          0 :     PyObject *binop = Py_None;
         722                 :          0 :     PyObject *initial = Py_None;
         723                 :            :
         724   [ #  #  #  #  :          0 :     fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, 1, 2, 0, argsbuf);
                 #  #  #  # ]
         725         [ #  # ]:          0 :     if (!fastargs) {
         726                 :          0 :         goto exit;
         727                 :            :     }
         728                 :          0 :     iterable = fastargs[0];
         729         [ #  # ]:          0 :     if (!noptargs) {
         730                 :          0 :         goto skip_optional_pos;
         731                 :            :     }
         732         [ #  # ]:          0 :     if (fastargs[1]) {
         733                 :          0 :         binop = fastargs[1];
         734         [ #  # ]:          0 :         if (!--noptargs) {
         735                 :          0 :             goto skip_optional_pos;
         736                 :            :         }
         737                 :            :     }
         738                 :          0 : skip_optional_pos:
         739         [ #  # ]:          0 :     if (!noptargs) {
         740                 :          0 :         goto skip_optional_kwonly;
         741                 :            :     }
         742                 :          0 :     initial = fastargs[2];
         743                 :          0 : skip_optional_kwonly:
         744                 :          0 :     return_value = itertools_accumulate_impl(type, iterable, binop, initial);
         745                 :            :
         746                 :          0 : exit:
         747                 :          0 :     return return_value;
         748                 :            : }
         749                 :            :
         750                 :            : PyDoc_STRVAR(itertools_compress__doc__,
         751                 :            : "compress(data, selectors)\n"
         752                 :            : "--\n"
         753                 :            : "\n"
         754                 :            : "Return data elements corresponding to true selector elements.\n"
         755                 :            : "\n"
         756                 :            : "Forms a shorter iterator from selected data elements using the selectors to\n"
         757                 :            : "choose the data elements.");
         758                 :            :
         759                 :            : static PyObject *
         760                 :            : itertools_compress_impl(PyTypeObject *type, PyObject *seq1, PyObject *seq2);
         761                 :            :
         762                 :            : static PyObject *
         763                 :          0 : itertools_compress(PyTypeObject *type, PyObject *args, PyObject *kwargs)
         764                 :            : {
         765                 :          0 :     PyObject *return_value = NULL;
         766                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
         767                 :            :
         768                 :            :     #define NUM_KEYWORDS 2
         769                 :            :     static struct {
         770                 :            :         PyGC_Head _this_is_not_used;
         771                 :            :         PyObject_VAR_HEAD
         772                 :            :         PyObject *ob_item[NUM_KEYWORDS];
         773                 :            :     } _kwtuple = {
         774                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
         775                 :            :         .ob_item = { &_Py_ID(data), &_Py_ID(selectors), },
         776                 :            :     };
         777                 :            :     #undef NUM_KEYWORDS
         778                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
         779                 :            :
         780                 :            :     #else  // !Py_BUILD_CORE
         781                 :            :     #  define KWTUPLE NULL
         782                 :            :     #endif  // !Py_BUILD_CORE
         783                 :            :
         784                 :            :     static const char * const _keywords[] = {"data", "selectors", NULL};
         785                 :            :     static _PyArg_Parser _parser = {
         786                 :            :         .keywords = _keywords,
         787                 :            :         .fname = "compress",
         788                 :            :         .kwtuple = KWTUPLE,
         789                 :            :     };
         790                 :            :     #undef KWTUPLE
         791                 :            :     PyObject *argsbuf[2];
         792                 :            :     PyObject * const *fastargs;
         793                 :          0 :     Py_ssize_t nargs = PyTuple_GET_SIZE(args);
         794                 :            :     PyObject *seq1;
         795                 :            :     PyObject *seq2;
         796                 :            :
         797   [ #  #  #  #  :          0 :     fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, 2, 2, 0, argsbuf);
                 #  #  #  # ]
         798         [ #  # ]:          0 :     if (!fastargs) {
         799                 :          0 :         goto exit;
         800                 :            :     }
         801                 :          0 :     seq1 = fastargs[0];
         802                 :          0 :     seq2 = fastargs[1];
         803                 :          0 :     return_value = itertools_compress_impl(type, seq1, seq2);
         804                 :            :
         805                 :          0 : exit:
         806                 :          0 :     return return_value;
         807                 :            : }
         808                 :            :
         809                 :            : PyDoc_STRVAR(itertools_filterfalse__doc__,
         810                 :            : "filterfalse(function, iterable, /)\n"
         811                 :            : "--\n"
         812                 :            : "\n"
         813                 :            : "Return those items of iterable for which function(item) is false.\n"
         814                 :            : "\n"
         815                 :            : "If function is None, return the items that are false.");
         816                 :            :
         817                 :            : static PyObject *
         818                 :            : itertools_filterfalse_impl(PyTypeObject *type, PyObject *func, PyObject *seq);
         819                 :            :
         820                 :            : static PyObject *
         821                 :          0 : itertools_filterfalse(PyTypeObject *type, PyObject *args, PyObject *kwargs)
         822                 :            : {
         823                 :          0 :     PyObject *return_value = NULL;
         824                 :          0 :     PyTypeObject *base_tp = clinic_state()->filterfalse_type;
         825                 :            :     PyObject *func;
         826                 :            :     PyObject *seq;
         827                 :            :
         828   [ #  #  #  #  :          0 :     if ((type == base_tp || type->tp_init == base_tp->tp_init) &&
                       #  # ]
         829         [ #  # ]:          0 :         !_PyArg_NoKeywords("filterfalse", kwargs)) {
         830                 :          0 :         goto exit;
         831                 :            :     }
         832   [ #  #  #  #  :          0 :     if (!_PyArg_CheckPositional("filterfalse", PyTuple_GET_SIZE(args), 2, 2)) {
                       #  # ]
         833                 :          0 :         goto exit;
         834                 :            :     }
         835                 :          0 :     func = PyTuple_GET_ITEM(args, 0);
         836                 :          0 :     seq = PyTuple_GET_ITEM(args, 1);
         837                 :          0 :     return_value = itertools_filterfalse_impl(type, func, seq);
         838                 :            :
         839                 :          0 : exit:
         840                 :          0 :     return return_value;
         841                 :            : }
         842                 :            :
         843                 :            : PyDoc_STRVAR(itertools_count__doc__,
         844                 :            : "count(start=0, step=1)\n"
         845                 :            : "--\n"
         846                 :            : "\n"
         847                 :            : "Return a count object whose .__next__() method returns consecutive values.\n"
         848                 :            : "\n"
         849                 :            : "Equivalent to:\n"
         850                 :            : "    def count(firstval=0, step=1):\n"
         851                 :            : "        x = firstval\n"
         852                 :            : "        while 1:\n"
         853                 :            : "            yield x\n"
         854                 :            : "            x += step");
         855                 :            :
         856                 :            : static PyObject *
         857                 :            : itertools_count_impl(PyTypeObject *type, PyObject *long_cnt,
         858                 :            :                      PyObject *long_step);
         859                 :            :
         860                 :            : static PyObject *
         861                 :          8 : itertools_count(PyTypeObject *type, PyObject *args, PyObject *kwargs)
         862                 :            : {
         863                 :          8 :     PyObject *return_value = NULL;
         864                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
         865                 :            :
         866                 :            :     #define NUM_KEYWORDS 2
         867                 :            :     static struct {
         868                 :            :         PyGC_Head _this_is_not_used;
         869                 :            :         PyObject_VAR_HEAD
         870                 :            :         PyObject *ob_item[NUM_KEYWORDS];
         871                 :            :     } _kwtuple = {
         872                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
         873                 :            :         .ob_item = { &_Py_ID(start), &_Py_ID(step), },
         874                 :            :     };
         875                 :            :     #undef NUM_KEYWORDS
         876                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
         877                 :            :
         878                 :            :     #else  // !Py_BUILD_CORE
         879                 :            :     #  define KWTUPLE NULL
         880                 :            :     #endif  // !Py_BUILD_CORE
         881                 :            :
         882                 :            :     static const char * const _keywords[] = {"start", "step", NULL};
         883                 :            :     static _PyArg_Parser _parser = {
         884                 :            :         .keywords = _keywords,
         885                 :            :         .fname = "count",
         886                 :            :         .kwtuple = KWTUPLE,
         887                 :            :     };
         888                 :            :     #undef KWTUPLE
         889                 :            :     PyObject *argsbuf[2];
         890                 :            :     PyObject * const *fastargs;
         891                 :          8 :     Py_ssize_t nargs = PyTuple_GET_SIZE(args);
         892         [ -  + ]:          8 :     Py_ssize_t noptargs = nargs + (kwargs ? PyDict_GET_SIZE(kwargs) : 0) - 0;
         893                 :          8 :     PyObject *long_cnt = NULL;
         894                 :          8 :     PyObject *long_step = NULL;
         895                 :            :
         896   [ +  -  +  -  :          8 :     fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, 0, 2, 0, argsbuf);
                 +  -  +  - ]
         897         [ -  + ]:          8 :     if (!fastargs) {
         898                 :          0 :         goto exit;
         899                 :            :     }
         900         [ +  + ]:          8 :     if (!noptargs) {
         901                 :          3 :         goto skip_optional_pos;
         902                 :            :     }
         903         [ +  - ]:          5 :     if (fastargs[0]) {
         904                 :          5 :         long_cnt = fastargs[0];
         905         [ +  - ]:          5 :         if (!--noptargs) {
         906                 :          5 :             goto skip_optional_pos;
         907                 :            :         }
         908                 :            :     }
         909                 :          0 :     long_step = fastargs[1];
         910                 :          8 : skip_optional_pos:
         911                 :          8 :     return_value = itertools_count_impl(type, long_cnt, long_step);
         912                 :            :
         913                 :          8 : exit:
         914                 :          8 :     return return_value;
         915                 :            : }
         916                 :            : /*[clinic end generated code: output=111cbd102c2a23c9 input=a9049054013a1b77]*/

Generated by: LCOV version 1.14