#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)

# include "pycore_gc.h" // PyGC_Head

# include "pycore_runtime.h" // _Py_ID()

#include "pycore_abstract.h" // _PyNumber_Index()

#include "pycore_modsupport.h" // _PyArg_UnpackKeywords()

PyDoc_STRVAR(zlib_compress__doc__,

" The window buffer size and container format.");

#define ZLIB_COMPRESS_METHODDEF \

{"compress", _PyCFunction_CAST(zlib_compress), METH_FASTCALL|METH_KEYWORDS, zlib_compress__doc__},

static PyObject *

zlib_compress_impl(PyObject *module, Py_buffer *data, int level, int wbits);

static PyObject *

zlib_compress(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

PyObject *return_value = NULL;

#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)

#define NUM_KEYWORDS 2

static struct {

PyGC_Head _this_is_not_used;

PyObject_VAR_HEAD

Py_hash_t ob_hash;

PyObject *ob_item[NUM_KEYWORDS];

} _kwtuple = {

.ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)

.ob_hash = -1,

.ob_item = { &_Py_ID(level), &_Py_ID(wbits), },

};

#undef NUM_KEYWORDS

#define KWTUPLE (&_kwtuple.ob_base.ob_base)

#else // !Py_BUILD_CORE

# define KWTUPLE NULL

#endif // !Py_BUILD_CORE

static const char * const _keywords[] = {"", "level", "wbits", NULL};

static _PyArg_Parser _parser = {

.keywords = _keywords,

.fname = "compress",

.kwtuple = KWTUPLE,

};

#undef KWTUPLE

PyObject *argsbuf[3];

Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;

Py_buffer data = {NULL, NULL};

int level = Z_DEFAULT_COMPRESSION;

int wbits = MAX_WBITS;

args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,

/*minpos*/ 1, /*maxpos*/ 3, /*minkw*/ 0, /*varpos*/ 0, argsbuf);

if (!args) {

goto exit;

}

if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {

goto exit;

}

if (!noptargs) {

goto skip_optional_pos;

}

if (args[1]) {

level = PyLong_AsInt(args[1]);

if (level == -1 && PyErr_Occurred()) {

goto exit;

}

if (!--noptargs) {

goto skip_optional_pos;

}

}

wbits = PyLong_AsInt(args[2]);

if (wbits == -1 && PyErr_Occurred()) {

goto exit;

}

skip_optional_pos:

return_value = zlib_compress_impl(module, &data, level, wbits);

exit:

/* Cleanup for data */

if (data.obj) {

PyBuffer_Release(&data);

}

return return_value;

}

PyDoc_STRVAR(zlib_decompress__doc__,

" The initial output buffer size.");

#define ZLIB_DECOMPRESS_METHODDEF \

{"decompress", _PyCFunction_CAST(zlib_decompress), METH_FASTCALL|METH_KEYWORDS, zlib_decompress__doc__},

static PyObject *

zlib_decompress_impl(PyObject *module, Py_buffer *data, int wbits,

Py_ssize_t bufsize);

static PyObject *

zlib_decompress(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

PyObject *return_value = NULL;

#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)

#define NUM_KEYWORDS 2

static struct {

PyGC_Head _this_is_not_used;

PyObject_VAR_HEAD

Py_hash_t ob_hash;

PyObject *ob_item[NUM_KEYWORDS];

} _kwtuple = {

.ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)

.ob_hash = -1,

.ob_item = { &_Py_ID(wbits), &_Py_ID(bufsize), },

};

#undef NUM_KEYWORDS

#define KWTUPLE (&_kwtuple.ob_base.ob_base)

#else // !Py_BUILD_CORE

# define KWTUPLE NULL

#endif // !Py_BUILD_CORE

static const char * const _keywords[] = {"", "wbits", "bufsize", NULL};

static _PyArg_Parser _parser = {

.keywords = _keywords,

.fname = "decompress",

.kwtuple = KWTUPLE,

};

#undef KWTUPLE

PyObject *argsbuf[3];

Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;

Py_buffer data = {NULL, NULL};

int wbits = MAX_WBITS;

Py_ssize_t bufsize = DEF_BUF_SIZE;

args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,

/*minpos*/ 1, /*maxpos*/ 3, /*minkw*/ 0, /*varpos*/ 0, argsbuf);

if (!args) {

goto exit;

}

if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {

goto exit;

}

if (!noptargs) {

goto skip_optional_pos;

}

if (args[1]) {

wbits = PyLong_AsInt(args[1]);

if (wbits == -1 && PyErr_Occurred()) {

goto exit;

}

if (!--noptargs) {

goto skip_optional_pos;

}

}

{

Py_ssize_t ival = -1;

PyObject *iobj = _PyNumber_Index(args[2]);

if (iobj != NULL) {

ival = PyLong_AsSsize_t(iobj);

Py_DECREF(iobj);

}

if (ival == -1 && PyErr_Occurred()) {

goto exit;

}

bufsize = ival;

if (bufsize < 0) {

PyErr_SetString(PyExc_ValueError,

"bufsize cannot be negative");

goto exit;

}

}

skip_optional_pos:

return_value = zlib_decompress_impl(module, &data, wbits, bufsize);

exit:

/* Cleanup for data */

if (data.obj) {

PyBuffer_Release(&data);

}

return return_value;

}

PyDoc_STRVAR(zlib_compressobj__doc__,

" containing subsequences that are likely to occur in the input data.");

#define ZLIB_COMPRESSOBJ_METHODDEF \

{"compressobj", _PyCFunction_CAST(zlib_compressobj), METH_FASTCALL|METH_KEYWORDS, zlib_compressobj__doc__},

static PyObject *

zlib_compressobj_impl(PyObject *module, int level, int method, int wbits,

int memLevel, int strategy, Py_buffer *zdict);

static PyObject *

zlib_compressobj(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

PyObject *return_value = NULL;

#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)

#define NUM_KEYWORDS 6

static struct {

PyGC_Head _this_is_not_used;

PyObject_VAR_HEAD

Py_hash_t ob_hash;

PyObject *ob_item[NUM_KEYWORDS];

} _kwtuple = {

.ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)

.ob_hash = -1,

.ob_item = { &_Py_ID(level), &_Py_ID(method), &_Py_ID(wbits), &_Py_ID(memLevel), &_Py_ID(strategy), &_Py_ID(zdict), },

};

#undef NUM_KEYWORDS

#define KWTUPLE (&_kwtuple.ob_base.ob_base)

#else // !Py_BUILD_CORE

# define KWTUPLE NULL

#endif // !Py_BUILD_CORE

static const char * const _keywords[] = {"level", "method", "wbits", "memLevel", "strategy", "zdict", NULL};

static _PyArg_Parser _parser = {

.keywords = _keywords,

.fname = "compressobj",

.kwtuple = KWTUPLE,

};

#undef KWTUPLE

PyObject *argsbuf[6];

Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;

int level = Z_DEFAULT_COMPRESSION;

int method = DEFLATED;

int wbits = MAX_WBITS;

int memLevel = DEF_MEM_LEVEL;

int strategy = Z_DEFAULT_STRATEGY;

Py_buffer zdict = {NULL, NULL};

args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,

/*minpos*/ 0, /*maxpos*/ 6, /*minkw*/ 0, /*varpos*/ 0, argsbuf);

if (!args) {

goto exit;

}

if (!noptargs) {

goto skip_optional_pos;

}

if (args[0]) {

level = PyLong_AsInt(args[0]);

if (level == -1 && PyErr_Occurred()) {

goto exit;

}

if (!--noptargs) {

goto skip_optional_pos;

}

}

if (args[1]) {

method = PyLong_AsInt(args[1]);

if (method == -1 && PyErr_Occurred()) {

goto exit;

}

if (!--noptargs) {

goto skip_optional_pos;

}

}

if (args[2]) {

wbits = PyLong_AsInt(args[2]);

if (wbits == -1 && PyErr_Occurred()) {

goto exit;

}

if (!--noptargs) {

goto skip_optional_pos;

}

}

if (args[3]) {

memLevel = PyLong_AsInt(args[3]);

if (memLevel == -1 && PyErr_Occurred()) {

goto exit;

}

if (!--noptargs) {

goto skip_optional_pos;

}

}

if (args[4]) {

strategy = PyLong_AsInt(args[4]);

if (strategy == -1 && PyErr_Occurred()) {

goto exit;

}

if (!--noptargs) {

goto skip_optional_pos;

}

}

if (PyObject_GetBuffer(args[5], &zdict, PyBUF_SIMPLE) != 0) {

goto exit;

}

skip_optional_pos:

return_value = zlib_compressobj_impl(module, level, method, wbits, memLevel, strategy, &zdict);

exit:

/* Cleanup for zdict */

if (zdict.obj) {

PyBuffer_Release(&zdict);

}

return return_value;

}

PyDoc_STRVAR(zlib_decompressobj__doc__,

" dictionary as used by the compressor that produced the input data.");

#define ZLIB_DECOMPRESSOBJ_METHODDEF \

{"decompressobj", _PyCFunction_CAST(zlib_decompressobj), METH_FASTCALL|METH_KEYWORDS, zlib_decompressobj__doc__},

static PyObject *

zlib_decompressobj_impl(PyObject *module, int wbits, PyObject *zdict);

static PyObject *

zlib_decompressobj(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

PyObject *return_value = NULL;

#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)

#define NUM_KEYWORDS 2

static struct {

PyGC_Head _this_is_not_used;

PyObject_VAR_HEAD

Py_hash_t ob_hash;

PyObject *ob_item[NUM_KEYWORDS];

} _kwtuple = {

.ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)

.ob_hash = -1,

.ob_item = { &_Py_ID(wbits), &_Py_ID(zdict), },

};

#undef NUM_KEYWORDS

#define KWTUPLE (&_kwtuple.ob_base.ob_base)

#else // !Py_BUILD_CORE

# define KWTUPLE NULL

#endif // !Py_BUILD_CORE

static const char * const _keywords[] = {"wbits", "zdict", NULL};

static _PyArg_Parser _parser = {

.keywords = _keywords,

.fname = "decompressobj",

.kwtuple = KWTUPLE,

};

#undef KWTUPLE

PyObject *argsbuf[2];

Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;

int wbits = MAX_WBITS;

PyObject *zdict = NULL;

args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,

/*minpos*/ 0, /*maxpos*/ 2, /*minkw*/ 0, /*varpos*/ 0, argsbuf);

if (!args) {

goto exit;

}

if (!noptargs) {

goto skip_optional_pos;

}

if (args[0]) {

wbits = PyLong_AsInt(args[0]);

if (wbits == -1 && PyErr_Occurred()) {

goto exit;

}

if (!--noptargs) {

goto skip_optional_pos;

}

}

zdict = args[1];

skip_optional_pos:

return_value = zlib_decompressobj_impl(module, wbits, zdict);

exit:

return return_value;

}

PyDoc_STRVAR(zlib_Compress_compress__doc__,

"Call the flush() method to clear these buffers.");

#define ZLIB_COMPRESS_COMPRESS_METHODDEF \

{"compress", _PyCFunction_CAST(zlib_Compress_compress), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, zlib_Compress_compress__doc__},

static PyObject *

zlib_Compress_compress_impl(compobject *self, PyTypeObject *cls,

Py_buffer *data);

static PyObject *

zlib_Compress_compress(PyObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

PyObject *return_value = NULL;

Py_buffer data = {NULL, NULL};

if (!_PyArg_NoKwnames("compress", kwnames)) {

goto exit;

}

if (!_PyArg_CheckPositional("compress", nargs, 1, 1)) {

goto exit;

}

if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {

goto exit;

}

return_value = zlib_Compress_compress_impl((compobject *)self, cls, &data);

exit:

/* Cleanup for data */

if (data.obj) {

PyBuffer_Release(&data);

}

return return_value;

}

PyDoc_STRVAR(zlib_Decompress_decompress__doc__,

"Call the flush() method to clear these buffers.");

#define ZLIB_DECOMPRESS_DECOMPRESS_METHODDEF \

{"decompress", _PyCFunction_CAST(zlib_Decompress_decompress), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, zlib_Decompress_decompress__doc__},

static PyObject *

zlib_Decompress_decompress_impl(compobject *self, PyTypeObject *cls,

Py_buffer *data, Py_ssize_t max_length);

static PyObject *

zlib_Decompress_decompress(PyObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

PyObject *return_value = NULL;

#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)

#define NUM_KEYWORDS 1

static struct {

PyGC_Head _this_is_not_used;

PyObject_VAR_HEAD

Py_hash_t ob_hash;

PyObject *ob_item[NUM_KEYWORDS];

} _kwtuple = {

.ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)

.ob_hash = -1,

.ob_item = { &_Py_ID(max_length), },

};

#undef NUM_KEYWORDS

#define KWTUPLE (&_kwtuple.ob_base.ob_base)

#else // !Py_BUILD_CORE

# define KWTUPLE NULL

#endif // !Py_BUILD_CORE

static const char * const _keywords[] = {"", "max_length", NULL};

static _PyArg_Parser _parser = {

.keywords = _keywords,

.fname = "decompress",

.kwtuple = KWTUPLE,

};

#undef KWTUPLE

PyObject *argsbuf[2];

Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;

Py_buffer data = {NULL, NULL};

Py_ssize_t max_length = 0;

args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,

/*minpos*/ 1, /*maxpos*/ 2, /*minkw*/ 0, /*varpos*/ 0, argsbuf);

if (!args) {

goto exit;

}

if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {

goto exit;

}

if (!noptargs) {

goto skip_optional_pos;

}

{

Py_ssize_t ival = -1;

PyObject *iobj = _PyNumber_Index(args[1]);

if (iobj != NULL) {

ival = PyLong_AsSsize_t(iobj);

Py_DECREF(iobj);

}

if (ival == -1 && PyErr_Occurred()) {

goto exit;

}

max_length = ival;

if (max_length < 0) {

PyErr_SetString(PyExc_ValueError,

"max_length cannot be negative");

goto exit;

}

}

skip_optional_pos:

return_value = zlib_Decompress_decompress_impl((compobject *)self, cls, &data, max_length);

exit:

/* Cleanup for data */

if (data.obj) {

PyBuffer_Release(&data);

}

return return_value;

}

PyDoc_STRVAR(zlib_Compress_flush__doc__,

" can still be compressed.");

#define ZLIB_COMPRESS_FLUSH_METHODDEF \

{"flush", _PyCFunction_CAST(zlib_Compress_flush), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, zlib_Compress_flush__doc__},

static PyObject *

zlib_Compress_flush_impl(compobject *self, PyTypeObject *cls, int mode);

static PyObject *

zlib_Compress_flush(PyObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

PyObject *return_value = NULL;

int mode = Z_FINISH;

if (!_PyArg_NoKwnames("flush", kwnames)) {

goto exit;

}

if (!_PyArg_CheckPositional("flush", nargs, 0, 1)) {

goto exit;

}

if (nargs < 1) {

goto skip_optional;

}

mode = PyLong_AsInt(args[0]);

if (mode == -1 && PyErr_Occurred()) {

goto exit;

}

skip_optional:

return_value = zlib_Compress_flush_impl((compobject *)self, cls, mode);

exit:

return return_value;

}

#if defined(HAVE_ZLIB_COPY)

PyDoc_STRVAR(zlib_Compress_copy__doc__,

"Return a copy of the compression object.");

#define ZLIB_COMPRESS_COPY_METHODDEF \

{"copy", _PyCFunction_CAST(zlib_Compress_copy), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, zlib_Compress_copy__doc__},

static PyObject *

zlib_Compress_copy_impl(compobject *self, PyTypeObject *cls);

static PyObject *

zlib_Compress_copy(PyObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

if (nargs || (kwnames && PyTuple_GET_SIZE(kwnames))) {

PyErr_SetString(PyExc_TypeError, "copy() takes no arguments");

return NULL;

}

return zlib_Compress_copy_impl((compobject *)self, cls);

}

#endif /* defined(HAVE_ZLIB_COPY) */

#if defined(HAVE_ZLIB_COPY)

PyDoc_STRVAR(zlib_Compress___copy____doc__,

"\n");

#define ZLIB_COMPRESS___COPY___METHODDEF \

{"__copy__", _PyCFunction_CAST(zlib_Compress___copy__), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, zlib_Compress___copy____doc__},

static PyObject *

zlib_Compress___copy___impl(compobject *self, PyTypeObject *cls);

static PyObject *

zlib_Compress___copy__(PyObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

if (nargs || (kwnames && PyTuple_GET_SIZE(kwnames))) {

PyErr_SetString(PyExc_TypeError, "__copy__() takes no arguments");

return NULL;

}

return zlib_Compress___copy___impl((compobject *)self, cls);

}

#endif /* defined(HAVE_ZLIB_COPY) */

#if defined(HAVE_ZLIB_COPY)

PyDoc_STRVAR(zlib_Compress___deepcopy____doc__,

"\n");

#define ZLIB_COMPRESS___DEEPCOPY___METHODDEF \

{"__deepcopy__", _PyCFunction_CAST(zlib_Compress___deepcopy__), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, zlib_Compress___deepcopy____doc__},

static PyObject *

zlib_Compress___deepcopy___impl(compobject *self, PyTypeObject *cls,

PyObject *memo);

static PyObject *

zlib_Compress___deepcopy__(PyObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

PyObject *return_value = NULL;

PyObject *memo;

if (!_PyArg_NoKwnames("__deepcopy__", kwnames)) {

goto exit;

}

if (!_PyArg_CheckPositional("__deepcopy__", nargs, 1, 1)) {

goto exit;

}

memo = args[0];

return_value = zlib_Compress___deepcopy___impl((compobject *)self, cls, memo);

exit:

return return_value;

}

#endif /* defined(HAVE_ZLIB_COPY) */

#if defined(HAVE_ZLIB_COPY)

PyDoc_STRVAR(zlib_Decompress_copy__doc__,

"Return a copy of the decompression object.");

#define ZLIB_DECOMPRESS_COPY_METHODDEF \

{"copy", _PyCFunction_CAST(zlib_Decompress_copy), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, zlib_Decompress_copy__doc__},

static PyObject *

zlib_Decompress_copy_impl(compobject *self, PyTypeObject *cls);

static PyObject *

zlib_Decompress_copy(PyObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

if (nargs || (kwnames && PyTuple_GET_SIZE(kwnames))) {

PyErr_SetString(PyExc_TypeError, "copy() takes no arguments");

return NULL;

}

return zlib_Decompress_copy_impl((compobject *)self, cls);

}

#endif /* defined(HAVE_ZLIB_COPY) */

#if defined(HAVE_ZLIB_COPY)

PyDoc_STRVAR(zlib_Decompress___copy____doc__,

"\n");

#define ZLIB_DECOMPRESS___COPY___METHODDEF \

{"__copy__", _PyCFunction_CAST(zlib_Decompress___copy__), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, zlib_Decompress___copy____doc__},

static PyObject *

zlib_Decompress___copy___impl(compobject *self, PyTypeObject *cls);

static PyObject *

zlib_Decompress___copy__(PyObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

if (nargs || (kwnames && PyTuple_GET_SIZE(kwnames))) {

PyErr_SetString(PyExc_TypeError, "__copy__() takes no arguments");

return NULL;

}

return zlib_Decompress___copy___impl((compobject *)self, cls);

}

#endif /* defined(HAVE_ZLIB_COPY) */

#if defined(HAVE_ZLIB_COPY)

PyDoc_STRVAR(zlib_Decompress___deepcopy____doc__,

"\n");

#define ZLIB_DECOMPRESS___DEEPCOPY___METHODDEF \

{"__deepcopy__", _PyCFunction_CAST(zlib_Decompress___deepcopy__), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, zlib_Decompress___deepcopy____doc__},

static PyObject *

zlib_Decompress___deepcopy___impl(compobject *self, PyTypeObject *cls,

PyObject *memo);

static PyObject *

zlib_Decompress___deepcopy__(PyObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

PyObject *return_value = NULL;

PyObject *memo;

if (!_PyArg_NoKwnames("__deepcopy__", kwnames)) {

goto exit;

}

if (!_PyArg_CheckPositional("__deepcopy__", nargs, 1, 1)) {

goto exit;

}

memo = args[0];

return_value = zlib_Decompress___deepcopy___impl((compobject *)self, cls, memo);

exit:

return return_value;

}

#endif /* defined(HAVE_ZLIB_COPY) */

PyDoc_STRVAR(zlib_Decompress_flush__doc__,

" the initial size of the output buffer.");

#define ZLIB_DECOMPRESS_FLUSH_METHODDEF \

{"flush", _PyCFunction_CAST(zlib_Decompress_flush), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, zlib_Decompress_flush__doc__},

static PyObject *

zlib_Decompress_flush_impl(compobject *self, PyTypeObject *cls,

Py_ssize_t length);

static PyObject *

zlib_Decompress_flush(PyObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

PyObject *return_value = NULL;

Py_ssize_t length = DEF_BUF_SIZE;

if (!_PyArg_NoKwnames("flush", kwnames)) {

goto exit;

}

if (!_PyArg_CheckPositional("flush", nargs, 0, 1)) {

goto exit;

}

if (nargs < 1) {

goto skip_optional;

}

{

Py_ssize_t ival = -1;

PyObject *iobj = _PyNumber_Index(args[0]);

if (iobj != NULL) {

ival = PyLong_AsSsize_t(iobj);

Py_DECREF(iobj);

}

if (ival == -1 && PyErr_Occurred()) {

goto exit;

}

length = ival;

}

skip_optional:

return_value = zlib_Decompress_flush_impl((compobject *)self, cls, length);

exit:

return return_value;

}

PyDoc_STRVAR(zlib__ZlibDecompressor_decompress__doc__,

"ignored and saved in the unused_data attribute.");

#define ZLIB__ZLIBDECOMPRESSOR_DECOMPRESS_METHODDEF \

{"decompress", _PyCFunction_CAST(zlib__ZlibDecompressor_decompress), METH_FASTCALL|METH_KEYWORDS, zlib__ZlibDecompressor_decompress__doc__},

static PyObject *

zlib__ZlibDecompressor_decompress_impl(ZlibDecompressor *self,

Py_buffer *data,

Py_ssize_t max_length);

static PyObject *

zlib__ZlibDecompressor_decompress(PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

PyObject *return_value = NULL;

#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)

#define NUM_KEYWORDS 2

static struct {

PyGC_Head _this_is_not_used;

PyObject_VAR_HEAD

Py_hash_t ob_hash;

PyObject *ob_item[NUM_KEYWORDS];

} _kwtuple = {

.ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)

.ob_hash = -1,

.ob_item = { &_Py_ID(data), &_Py_ID(max_length), },

};

#undef NUM_KEYWORDS

#define KWTUPLE (&_kwtuple.ob_base.ob_base)

#else // !Py_BUILD_CORE

# define KWTUPLE NULL

#endif // !Py_BUILD_CORE

static const char * const _keywords[] = {"data", "max_length", NULL};

static _PyArg_Parser _parser = {

.keywords = _keywords,

.fname = "decompress",

.kwtuple = KWTUPLE,

};

#undef KWTUPLE

PyObject *argsbuf[2];

Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;

Py_buffer data = {NULL, NULL};

Py_ssize_t max_length = -1;

args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,

/*minpos*/ 1, /*maxpos*/ 2, /*minkw*/ 0, /*varpos*/ 0, argsbuf);

if (!args) {

goto exit;

}

if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {

goto exit;

}

if (!noptargs) {

goto skip_optional_pos;

}

{

Py_ssize_t ival = -1;

PyObject *iobj = _PyNumber_Index(args[1]);

if (iobj != NULL) {

ival = PyLong_AsSsize_t(iobj);

Py_DECREF(iobj);

}

if (ival == -1 && PyErr_Occurred()) {

goto exit;

}

max_length = ival;

}

skip_optional_pos:

return_value = zlib__ZlibDecompressor_decompress_impl((ZlibDecompressor *)self, &data, max_length);

exit:

/* Cleanup for data */

if (data.obj) {

PyBuffer_Release(&data);

}

return return_value;

}

PyDoc_STRVAR(zlib__ZlibDecompressor__doc__,

" compressor that produced the input data.");

static PyObject *

zlib__ZlibDecompressor_impl(PyTypeObject *type, int wbits, PyObject *zdict);

static PyObject *

zlib__ZlibDecompressor(PyTypeObject *type, PyObject *args, PyObject *kwargs)

{

PyObject *return_value = NULL;

#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)

#define NUM_KEYWORDS 2

static struct {

PyGC_Head _this_is_not_used;

PyObject_VAR_HEAD

Py_hash_t ob_hash;

PyObject *ob_item[NUM_KEYWORDS];

} _kwtuple = {

.ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)

.ob_hash = -1,

.ob_item = { &_Py_ID(wbits), &_Py_ID(zdict), },

};

#undef NUM_KEYWORDS

#define KWTUPLE (&_kwtuple.ob_base.ob_base)

#else // !Py_BUILD_CORE

# define KWTUPLE NULL

#endif // !Py_BUILD_CORE

static const char * const _keywords[] = {"wbits", "zdict", NULL};

static _PyArg_Parser _parser = {

.keywords = _keywords,

.fname = "_ZlibDecompressor",

.kwtuple = KWTUPLE,

};

#undef KWTUPLE

PyObject *argsbuf[2];

PyObject * const *fastargs;

Py_ssize_t nargs = PyTuple_GET_SIZE(args);

Py_ssize_t noptargs = nargs + (kwargs ? PyDict_GET_SIZE(kwargs) : 0) - 0;

int wbits = MAX_WBITS;

PyObject *zdict = NULL;

fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser,