#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()

static PyObject *

long_new_impl(PyTypeObject *type, PyObject *x, PyObject *obase);

static PyObject *

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

{

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

PyObject *ob_item[NUM_KEYWORDS];

} _kwtuple = {

.ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)

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

};

#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[] = {"", "base", NULL};

static _PyArg_Parser _parser = {

.keywords = _keywords,

.fname = "int",

.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;

PyObject *x = NULL;

PyObject *obase = NULL;

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

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

if (!fastargs) {

goto exit;

}

if (nargs < 1) {

goto skip_optional_posonly;

}

noptargs--;

x = fastargs[0];

skip_optional_posonly:

if (!noptargs) {

goto skip_optional_pos;

}

obase = fastargs[1];

skip_optional_pos:

return_value = long_new_impl(type, x, obase);

exit:

return return_value;

}

PyDoc_STRVAR(int___getnewargs____doc__,

"\n");

#define INT___GETNEWARGS___METHODDEF \

{"__getnewargs__", (PyCFunction)int___getnewargs__, METH_NOARGS, int___getnewargs____doc__},

static PyObject *

int___getnewargs___impl(PyObject *self);

static PyObject *

int___getnewargs__(PyObject *self, PyObject *Py_UNUSED(ignored))

{

return int___getnewargs___impl(self);

}

PyDoc_STRVAR(int___format____doc__,

"Convert to a string according to format_spec.");

#define INT___FORMAT___METHODDEF \

{"__format__", (PyCFunction)int___format__, METH_O, int___format____doc__},

static PyObject *

int___format___impl(PyObject *self, PyObject *format_spec);

static PyObject *

int___format__(PyObject *self, PyObject *arg)

{

PyObject *return_value = NULL;

PyObject *format_spec;

if (!PyUnicode_Check(arg)) {

_PyArg_BadArgument("__format__", "argument", "str", arg);

goto exit;

}

format_spec = arg;

return_value = int___format___impl(self, format_spec);

exit:

return return_value;

}

PyDoc_STRVAR(int___round____doc__,

"Rounding with an ndigits argument also returns an integer.");

#define INT___ROUND___METHODDEF \

{"__round__", _PyCFunction_CAST(int___round__), METH_FASTCALL, int___round____doc__},

static PyObject *

int___round___impl(PyObject *self, PyObject *o_ndigits);

static PyObject *

int___round__(PyObject *self, PyObject *const *args, Py_ssize_t nargs)

{

PyObject *return_value = NULL;

PyObject *o_ndigits = Py_None;

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

goto exit;

}

if (nargs < 1) {

goto skip_optional;

}

o_ndigits = args[0];

skip_optional:

return_value = int___round___impl(self, o_ndigits);

exit:

return return_value;

}

PyDoc_STRVAR(int___sizeof____doc__,

"Returns size in memory, in bytes.");

#define INT___SIZEOF___METHODDEF \

{"__sizeof__", (PyCFunction)int___sizeof__, METH_NOARGS, int___sizeof____doc__},

static Py_ssize_t

int___sizeof___impl(PyObject *self);

static PyObject *

int___sizeof__(PyObject *self, PyObject *Py_UNUSED(ignored))

{

PyObject *return_value = NULL;

Py_ssize_t _return_value;

_return_value = int___sizeof___impl(self);

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

goto exit;

}

return_value = PyLong_FromSsize_t(_return_value);

exit:

return return_value;

}

PyDoc_STRVAR(int_bit_length__doc__,

"6");

#define INT_BIT_LENGTH_METHODDEF \

{"bit_length", (PyCFunction)int_bit_length, METH_NOARGS, int_bit_length__doc__},

static PyObject *

int_bit_length_impl(PyObject *self);

static PyObject *

int_bit_length(PyObject *self, PyObject *Py_UNUSED(ignored))

{

return int_bit_length_impl(self);

}

PyDoc_STRVAR(int_bit_count__doc__,

"3");

#define INT_BIT_COUNT_METHODDEF \

{"bit_count", (PyCFunction)int_bit_count, METH_NOARGS, int_bit_count__doc__},

static PyObject *

int_bit_count_impl(PyObject *self);

static PyObject *

int_bit_count(PyObject *self, PyObject *Py_UNUSED(ignored))

{

return int_bit_count_impl(self);

}

PyDoc_STRVAR(int_as_integer_ratio__doc__,

"(0, 1)");

#define INT_AS_INTEGER_RATIO_METHODDEF \

{"as_integer_ratio", (PyCFunction)int_as_integer_ratio, METH_NOARGS, int_as_integer_ratio__doc__},

static PyObject *

int_as_integer_ratio_impl(PyObject *self);

static PyObject *

int_as_integer_ratio(PyObject *self, PyObject *Py_UNUSED(ignored))

{

return int_as_integer_ratio_impl(self);

}

PyDoc_STRVAR(int_to_bytes__doc__,

" is raised.");

#define INT_TO_BYTES_METHODDEF \

{"to_bytes", _PyCFunction_CAST(int_to_bytes), METH_FASTCALL|METH_KEYWORDS, int_to_bytes__doc__},

static PyObject *

int_to_bytes_impl(PyObject *self, Py_ssize_t length, PyObject *byteorder,

int is_signed);

static PyObject *

int_to_bytes(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 3

static struct {

PyGC_Head _this_is_not_used;

PyObject_VAR_HEAD

PyObject *ob_item[NUM_KEYWORDS];

} _kwtuple = {

.ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)

.ob_item = { &_Py_ID(length), &_Py_ID(byteorder), &_Py_ID(signed), },

};

#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[] = {"length", "byteorder", "signed", NULL};

static _PyArg_Parser _parser = {

.keywords = _keywords,

.fname = "to_bytes",

.kwtuple = KWTUPLE,

};

#undef KWTUPLE

PyObject *argsbuf[3];

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

Py_ssize_t length = 1;

PyObject *byteorder = NULL;

int is_signed = 0;

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]) {

{

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;

}

if (!--noptargs) {

goto skip_optional_pos;

}

}

if (args[1]) {

if (!PyUnicode_Check(args[1])) {

_PyArg_BadArgument("to_bytes", "argument 'byteorder'", "str", args[1]);

goto exit;

}

byteorder = args[1];

if (!--noptargs) {

goto skip_optional_pos;

}

}

skip_optional_pos:

if (!noptargs) {

goto skip_optional_kwonly;

}

is_signed = PyObject_IsTrue(args[2]);

if (is_signed < 0) {

goto exit;

}

skip_optional_kwonly:

return_value = int_to_bytes_impl(self, length, byteorder, is_signed);

exit:

return return_value;

}

PyDoc_STRVAR(int_from_bytes__doc__,

" Indicates whether two\'s complement is used to represent the integer.");

#define INT_FROM_BYTES_METHODDEF \

{"from_bytes", _PyCFunction_CAST(int_from_bytes), METH_FASTCALL|METH_KEYWORDS|METH_CLASS, int_from_bytes__doc__},

static PyObject *

int_from_bytes_impl(PyTypeObject *type, PyObject *bytes_obj,

PyObject *byteorder, int is_signed);

static PyObject *

int_from_bytes(PyTypeObject *type, 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 3

static struct {

PyGC_Head _this_is_not_used;

PyObject_VAR_HEAD

PyObject *ob_item[NUM_KEYWORDS];

} _kwtuple = {

.ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)

.ob_item = { &_Py_ID(bytes), &_Py_ID(byteorder), &_Py_ID(signed), },

};

#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[] = {"bytes", "byteorder", "signed", NULL};

static _PyArg_Parser _parser = {

.keywords = _keywords,

.fname = "from_bytes",

.kwtuple = KWTUPLE,

};

#undef KWTUPLE

PyObject *argsbuf[3];

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

PyObject *bytes_obj;

PyObject *byteorder = NULL;

int is_signed = 0;

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

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

if (!args) {

goto exit;

}

bytes_obj = args[0];

if (!noptargs) {

goto skip_optional_pos;

}

if (args[1]) {

if (!PyUnicode_Check(args[1])) {

_PyArg_BadArgument("from_bytes", "argument 'byteorder'", "str", args[1]);

goto exit;

}

byteorder = args[1];

if (!--noptargs) {

goto skip_optional_pos;

}

}

skip_optional_pos:

if (!noptargs) {

goto skip_optional_kwonly;

}

is_signed = PyObject_IsTrue(args[2]);

if (is_signed < 0) {

goto exit;

}

skip_optional_kwonly:

return_value = int_from_bytes_impl(type, bytes_obj, byteorder, is_signed);

exit:

return return_value;

}

PyDoc_STRVAR(int_is_integer__doc__,

"Returns True. Exists for duck type compatibility with float.is_integer.");

#define INT_IS_INTEGER_METHODDEF \

{"is_integer", (PyCFunction)int_is_integer, METH_NOARGS, int_is_integer__doc__},

static PyObject *

int_is_integer_impl(PyObject *self);

static PyObject *

int_is_integer(PyObject *self, PyObject *Py_UNUSED(ignored))

{

return int_is_integer_impl(self);

}