/*[clinic input]

preserve

[clinic start generated code]*/

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

# include "pycore_gc.h" // PyGC_Head

#endif

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

#include "pycore_long.h" // _PyLong_UnsignedShort_Converter()

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

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

PyDoc_STRVAR(test_empty_function__doc__,

"test_empty_function($module, /)\n"

"--\n"

"\n");

#define TEST_EMPTY_FUNCTION_METHODDEF \

{"test_empty_function", (PyCFunction)test_empty_function, METH_NOARGS, test_empty_function__doc__},

static PyObject *

test_empty_function_impl(PyObject *module);

static PyObject *

test_empty_function(PyObject *module, PyObject *Py_UNUSED(ignored))

{

return test_empty_function_impl(module);

}

PyDoc_STRVAR(objects_converter__doc__,

"objects_converter($module, a, b=<unrepresentable>, /)\n"

"--\n"

"\n");

#define OBJECTS_CONVERTER_METHODDEF \

{"objects_converter", _PyCFunction_CAST(objects_converter), METH_FASTCALL, objects_converter__doc__},

static PyObject *

objects_converter_impl(PyObject *module, PyObject *a, PyObject *b);

static PyObject *

objects_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)

{

PyObject *return_value = NULL;

PyObject *a;

PyObject *b = NULL;

if (!_PyArg_CheckPositional("objects_converter", nargs, 1, 2)) {

goto exit;

}

a = args[0];

if (nargs < 2) {

goto skip_optional;

}

b = args[1];

skip_optional:

return_value = objects_converter_impl(module, a, b);

exit:

return return_value;

}

PyDoc_STRVAR(bytes_object_converter__doc__,

"bytes_object_converter($module, a, /)\n"

"--\n"

"\n");

#define BYTES_OBJECT_CONVERTER_METHODDEF \

{"bytes_object_converter", (PyCFunction)bytes_object_converter, METH_O, bytes_object_converter__doc__},

static PyObject *

bytes_object_converter_impl(PyObject *module, PyBytesObject *a);

static PyObject *

bytes_object_converter(PyObject *module, PyObject *arg)

{

PyObject *return_value = NULL;

PyBytesObject *a;

if (!PyBytes_Check(arg)) {

_PyArg_BadArgument("bytes_object_converter", "argument", "bytes", arg);

goto exit;

}

a = (PyBytesObject *)arg;

return_value = bytes_object_converter_impl(module, a);

exit:

return return_value;

}

PyDoc_STRVAR(byte_array_object_converter__doc__,

"byte_array_object_converter($module, a, /)\n"

"--\n"

"\n");

#define BYTE_ARRAY_OBJECT_CONVERTER_METHODDEF \

{"byte_array_object_converter", (PyCFunction)byte_array_object_converter, METH_O, byte_array_object_converter__doc__},

static PyObject *

byte_array_object_converter_impl(PyObject *module, PyByteArrayObject *a);

static PyObject *

byte_array_object_converter(PyObject *module, PyObject *arg)

{

PyObject *return_value = NULL;

PyByteArrayObject *a;

if (!PyByteArray_Check(arg)) {

_PyArg_BadArgument("byte_array_object_converter", "argument", "bytearray", arg);

goto exit;

}

a = (PyByteArrayObject *)arg;

return_value = byte_array_object_converter_impl(module, a);

exit:

return return_value;

}

PyDoc_STRVAR(unicode_converter__doc__,

"unicode_converter($module, a, /)\n"

"--\n"

"\n");

#define UNICODE_CONVERTER_METHODDEF \

{"unicode_converter", (PyCFunction)unicode_converter, METH_O, unicode_converter__doc__},

static PyObject *

unicode_converter_impl(PyObject *module, PyObject *a);

static PyObject *

unicode_converter(PyObject *module, PyObject *arg)

{

PyObject *return_value = NULL;

PyObject *a;

if (!PyUnicode_Check(arg)) {

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

goto exit;

}

a = arg;

return_value = unicode_converter_impl(module, a);

exit:

return return_value;

}

PyDoc_STRVAR(bool_converter__doc__,

"bool_converter($module, a=True, b=True, c=True, /)\n"

"--\n"

"\n");

#define BOOL_CONVERTER_METHODDEF \

{"bool_converter", _PyCFunction_CAST(bool_converter), METH_FASTCALL, bool_converter__doc__},

static PyObject *

bool_converter_impl(PyObject *module, int a, int b, int c);

static PyObject *

bool_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)

{

PyObject *return_value = NULL;

int a = 1;

int b = 1;

int c = 1;

if (!_PyArg_CheckPositional("bool_converter", nargs, 0, 3)) {

goto exit;

}

if (nargs < 1) {

goto skip_optional;

}

a = PyObject_IsTrue(args[0]);

if (a < 0) {

goto exit;

}

if (nargs < 2) {

goto skip_optional;

}

b = PyObject_IsTrue(args[1]);

if (b < 0) {

goto exit;

}

if (nargs < 3) {

goto skip_optional;

}

c = PyLong_AsInt(args[2]);

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

goto exit;

}

skip_optional:

return_value = bool_converter_impl(module, a, b, c);

exit:

return return_value;

}

PyDoc_STRVAR(char_converter__doc__,

"char_converter($module, a=b\'A\', b=b\'\\x07\', c=b\'\\x08\', d=b\'\\t\', e=b\'\\n\',\n"

" f=b\'\\x0b\', g=b\'\\x0c\', h=b\'\\r\', i=b\'\"\', j=b\"\'\", k=b\'?\',\n"

" l=b\'\\\\\', m=b\'\\x00\', n=b\'\\xff\', /)\n"

"--\n"

"\n");

#define CHAR_CONVERTER_METHODDEF \

{"char_converter", _PyCFunction_CAST(char_converter), METH_FASTCALL, char_converter__doc__},

static PyObject *

char_converter_impl(PyObject *module, char a, char b, char c, char d, char e,

char f, char g, char h, char i, char j, char k, char l,

char m, char n);

static PyObject *

char_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)

{

PyObject *return_value = NULL;

char a = 'A';

char b = '\x07';

char c = '\x08';

char d = '\t';

char e = '\n';

char f = '\x0b';

char g = '\x0c';

char h = '\r';

char i = '"';

char j = '\'';

char k = '?';

char l = '\\';

char m = '\x00';

char n = '\xff';

if (!_PyArg_CheckPositional("char_converter", nargs, 0, 14)) {

goto exit;

}

if (nargs < 1) {

goto skip_optional;

}

if (PyBytes_Check(args[0])) {

if (PyBytes_GET_SIZE(args[0]) != 1) {

PyErr_Format(PyExc_TypeError,

"char_converter(): argument 1 must be a byte string of length 1, "

"not a bytes object of length %zd",

PyBytes_GET_SIZE(args[0]));

goto exit;

}

a = PyBytes_AS_STRING(args[0])[0];

}

else if (PyByteArray_Check(args[0])) {

if (PyByteArray_GET_SIZE(args[0]) != 1) {

PyErr_Format(PyExc_TypeError,

"char_converter(): argument 1 must be a byte string of length 1, "

"not a bytearray object of length %zd",

PyByteArray_GET_SIZE(args[0]));

goto exit;

}

a = PyByteArray_AS_STRING(args[0])[0];

}

else {

_PyArg_BadArgument("char_converter", "argument 1", "a byte string of length 1", args[0]);

goto exit;

}

if (nargs < 2) {

goto skip_optional;

}

if (PyBytes_Check(args[1])) {

if (PyBytes_GET_SIZE(args[1]) != 1) {

PyErr_Format(PyExc_TypeError,

"char_converter(): argument 2 must be a byte string of length 1, "

"not a bytes object of length %zd",

PyBytes_GET_SIZE(args[1]));

goto exit;

}

b = PyBytes_AS_STRING(args[1])[0];

}

else if (PyByteArray_Check(args[1])) {

if (PyByteArray_GET_SIZE(args[1]) != 1) {

PyErr_Format(PyExc_TypeError,

"char_converter(): argument 2 must be a byte string of length 1, "

"not a bytearray object of length %zd",

PyByteArray_GET_SIZE(args[1]));

goto exit;

}

b = PyByteArray_AS_STRING(args[1])[0];

}

else {

_PyArg_BadArgument("char_converter", "argument 2", "a byte string of length 1", args[1]);

goto exit;

}

if (nargs < 3) {

goto skip_optional;

}

if (PyBytes_Check(args[2])) {

if (PyBytes_GET_SIZE(args[2]) != 1) {

PyErr_Format(PyExc_TypeError,

"char_converter(): argument 3 must be a byte string of length 1, "

"not a bytes object of length %zd",

PyBytes_GET_SIZE(args[2]));

goto exit;

}

c = PyBytes_AS_STRING(args[2])[0];

}

else if (PyByteArray_Check(args[2])) {

if (PyByteArray_GET_SIZE(args[2]) != 1) {

PyErr_Format(PyExc_TypeError,

"char_converter(): argument 3 must be a byte string of length 1, "

"not a bytearray object of length %zd",

PyByteArray_GET_SIZE(args[2]));

goto exit;

}

c = PyByteArray_AS_STRING(args[2])[0];

}

else {

_PyArg_BadArgument("char_converter", "argument 3", "a byte string of length 1", args[2]);

goto exit;

}

if (nargs < 4) {

goto skip_optional;

}

if (PyBytes_Check(args[3])) {

if (PyBytes_GET_SIZE(args[3]) != 1) {

PyErr_Format(PyExc_TypeError,

"char_converter(): argument 4 must be a byte string of length 1, "

"not a bytes object of length %zd",

PyBytes_GET_SIZE(args[3]));

goto exit;

}

d = PyBytes_AS_STRING(args[3])[0];

}

else if (PyByteArray_Check(args[3])) {

if (PyByteArray_GET_SIZE(args[3]) != 1) {

PyErr_Format(PyExc_TypeError,

"char_converter(): argument 4 must be a byte string of length 1, "

"not a bytearray object of length %zd",

PyByteArray_GET_SIZE(args[3]));

goto exit;

}

d = PyByteArray_AS_STRING(args[3])[0];

}

else {

_PyArg_BadArgument("char_converter", "argument 4", "a byte string of length 1", args[3]);

goto exit;

}

if (nargs < 5) {

goto skip_optional;

}

if (PyBytes_Check(args[4])) {

if (PyBytes_GET_SIZE(args[4]) != 1) {

PyErr_Format(PyExc_TypeError,

"char_converter(): argument 5 must be a byte string of length 1, "

"not a bytes object of length %zd",

PyBytes_GET_SIZE(args[4]));

goto exit;

}

e = PyBytes_AS_STRING(args[4])[0];

}

else if (PyByteArray_Check(args[4])) {

if (PyByteArray_GET_SIZE(args[4]) != 1) {

PyErr_Format(PyExc_TypeError,

"char_converter(): argument 5 must be a byte string of length 1, "

"not a bytearray object of length %zd",

PyByteArray_GET_SIZE(args[4]));

goto exit;

}

e = PyByteArray_AS_STRING(args[4])[0];

}

else {

_PyArg_BadArgument("char_converter", "argument 5", "a byte string of length 1", args[4]);

goto exit;

}

if (nargs < 6) {

goto skip_optional;

}

if (PyBytes_Check(args[5])) {

if (PyBytes_GET_SIZE(args[5]) != 1) {

PyErr_Format(PyExc_TypeError,

"char_converter(): argument 6 must be a byte string of length 1, "

"not a bytes object of length %zd",

PyBytes_GET_SIZE(args[5]));

goto exit;

}

f = PyBytes_AS_STRING(args[5])[0];

}

else if (PyByteArray_Check(args[5])) {

if (PyByteArray_GET_SIZE(args[5]) != 1) {

PyErr_Format(PyExc_TypeError,

"char_converter(): argument 6 must be a byte string of length 1, "

"not a bytearray object of length %zd",

PyByteArray_GET_SIZE(args[5]));

goto exit;

}

f = PyByteArray_AS_STRING(args[5])[0];

}

else {

_PyArg_BadArgument("char_converter", "argument 6", "a byte string of length 1", args[5]);

goto exit;

}

if (nargs < 7) {

goto skip_optional;

}

if (PyBytes_Check(args[6])) {

if (PyBytes_GET_SIZE(args[6]) != 1) {

PyErr_Format(PyExc_TypeError,

"char_converter(): argument 7 must be a byte string of length 1, "

"not a bytes object of length %zd",

PyBytes_GET_SIZE(args[6]));

goto exit;

}

g = PyBytes_AS_STRING(args[6])[0];

}

else if (PyByteArray_Check(args[6])) {

if (PyByteArray_GET_SIZE(args[6]) != 1) {

PyErr_Format(PyExc_TypeError,

"char_converter(): argument 7 must be a byte string of length 1, "

"not a bytearray object of length %zd",

PyByteArray_GET_SIZE(args[6]));

goto exit;

}

g = PyByteArray_AS_STRING(args[6])[0];

}

else {

_PyArg_BadArgument("char_converter", "argument 7", "a byte string of length 1", args[6]);

goto exit;

}

if (nargs < 8) {

goto skip_optional;

}

if (PyBytes_Check(args[7])) {

if (PyBytes_GET_SIZE(args[7]) != 1) {

PyErr_Format(PyExc_TypeError,

"char_converter(): argument 8 must be a byte string of length 1, "

"not a bytes object of length %zd",

PyBytes_GET_SIZE(args[7]));

goto exit;

}

h = PyBytes_AS_STRING(args[7])[0];

}

else if (PyByteArray_Check(args[7])) {

if (PyByteArray_GET_SIZE(args[7]) != 1) {

PyErr_Format(PyExc_TypeError,

"char_converter(): argument 8 must be a byte string of length 1, "

"not a bytearray object of length %zd",

PyByteArray_GET_SIZE(args[7]));

goto exit;

}

h = PyByteArray_AS_STRING(args[7])[0];

}

else {

_PyArg_BadArgument("char_converter", "argument 8", "a byte string of length 1", args[7]);

goto exit;

}

if (nargs < 9) {

goto skip_optional;

}

if (PyBytes_Check(args[8])) {

if (PyBytes_GET_SIZE(args[8]) != 1) {

PyErr_Format(PyExc_TypeError,

"char_converter(): argument 9 must be a byte string of length 1, "

"not a bytes object of length %zd",

PyBytes_GET_SIZE(args[8]));

goto exit;

}

i = PyBytes_AS_STRING(args[8])[0];

}

else if (PyByteArray_Check(args[8])) {

if (PyByteArray_GET_SIZE(args[8]) != 1) {

PyErr_Format(PyExc_TypeError,

"char_converter(): argument 9 must be a byte string of length 1, "

"not a bytearray object of length %zd",

PyByteArray_GET_SIZE(args[8]));

goto exit;

}

i = PyByteArray_AS_STRING(args[8])[0];

}

else {

_PyArg_BadArgument("char_converter", "argument 9", "a byte string of length 1", args[8]);

goto exit;

}

if (nargs < 10) {

goto skip_optional;

}

if (PyBytes_Check(args[9])) {

if (PyBytes_GET_SIZE(args[9]) != 1) {

PyErr_Format(PyExc_TypeError,

"char_converter(): argument 10 must be a byte string of length 1, "

"not a bytes object of length %zd",

PyBytes_GET_SIZE(args[9]));

goto exit;

}

j = PyBytes_AS_STRING(args[9])[0];

}

else if (PyByteArray_Check(args[9])) {

if (PyByteArray_GET_SIZE(args[9]) != 1) {

PyErr_Format(PyExc_TypeError,

"char_converter(): argument 10 must be a byte string of length 1, "

"not a bytearray object of length %zd",

PyByteArray_GET_SIZE(args[9]));

goto exit;

}

j = PyByteArray_AS_STRING(args[9])[0];

}

else {

_PyArg_BadArgument("char_converter", "argument 10", "a byte string of length 1", args[9]);

goto exit;

}

if (nargs < 11) {

goto skip_optional;

}

if (PyBytes_Check(args[10])) {

if (PyBytes_GET_SIZE(args[10]) != 1) {

PyErr_Format(PyExc_TypeError,

"char_converter(): argument 11 must be a byte string of length 1, "

"not a bytes object of length %zd",

PyBytes_GET_SIZE(args[10]));

goto exit;

}

k = PyBytes_AS_STRING(args[10])[0];

}

else if (PyByteArray_Check(args[10])) {

if (PyByteArray_GET_SIZE(args[10]) != 1) {

PyErr_Format(PyExc_TypeError,

"char_converter(): argument 11 must be a byte string of length 1, "

"not a bytearray object of length %zd",

PyByteArray_GET_SIZE(args[10]));

goto exit;

}

k = PyByteArray_AS_STRING(args[10])[0];

}

else {

_PyArg_BadArgument("char_converter", "argument 11", "a byte string of length 1", args[10]);

goto exit;

}

if (nargs < 12) {

goto skip_optional;

}

if (PyBytes_Check(args[11])) {

if (PyBytes_GET_SIZE(args[11]) != 1) {

PyErr_Format(PyExc_TypeError,

"char_converter(): argument 12 must be a byte string of length 1, "

"not a bytes object of length %zd",

PyBytes_GET_SIZE(args[11]));

goto exit;

}

l = PyBytes_AS_STRING(args[11])[0];

}

else if (PyByteArray_Check(args[11])) {

if (PyByteArray_GET_SIZE(args[11]) != 1) {

PyErr_Format(PyExc_TypeError,

"char_converter(): argument 12 must be a byte string of length 1, "

"not a bytearray object of length %zd",

PyByteArray_GET_SIZE(args[11]));

goto exit;

}

l = PyByteArray_AS_STRING(args[11])[0];

}

else {

_PyArg_BadArgument("char_converter", "argument 12", "a byte string of length 1", args[11]);

goto exit;

}

if (nargs < 13) {

goto skip_optional;

}

if (PyBytes_Check(args[12])) {

if (PyBytes_GET_SIZE(args[12]) != 1) {

PyErr_Format(PyExc_TypeError,

"char_converter(): argument 13 must be a byte string of length 1, "

"not a bytes object of length %zd",

PyBytes_GET_SIZE(args[12]));

goto exit;

}

m = PyBytes_AS_STRING(args[12])[0];

}

else if (PyByteArray_Check(args[12])) {

if (PyByteArray_GET_SIZE(args[12]) != 1) {

PyErr_Format(PyExc_TypeError,

"char_converter(): argument 13 must be a byte string of length 1, "

"not a bytearray object of length %zd",

PyByteArray_GET_SIZE(args[12]));

goto exit;

}

m = PyByteArray_AS_STRING(args[12])[0];

}

else {

_PyArg_BadArgument("char_converter", "argument 13", "a byte string of length 1", args[12]);

goto exit;

}

if (nargs < 14) {

goto skip_optional;

}

if (PyBytes_Check(args[13])) {

if (PyBytes_GET_SIZE(args[13]) != 1) {

PyErr_Format(PyExc_TypeError,

"char_converter(): argument 14 must be a byte string of length 1, "

"not a bytes object of length %zd",

PyBytes_GET_SIZE(args[13]));

goto exit;

}

n = PyBytes_AS_STRING(args[13])[0];

}

else if (PyByteArray_Check(args[13])) {

if (PyByteArray_GET_SIZE(args[13]) != 1) {

PyErr_Format(PyExc_TypeError,

"char_converter(): argument 14 must be a byte string of length 1, "

"not a bytearray object of length %zd",

PyByteArray_GET_SIZE(args[13]));

goto exit;

}

n = PyByteArray_AS_STRING(args[13])[0];

}

else {

_PyArg_BadArgument("char_converter", "argument 14", "a byte string of length 1", args[13]);

goto exit;

}

skip_optional:

return_value = char_converter_impl(module, a, b, c, d, e, f, g, h, i, j, k, l, m, n);

exit:

return return_value;

}

PyDoc_STRVAR(unsigned_char_converter__doc__,

"unsigned_char_converter($module, a=12, b=34, c=56, /)\n"

"--\n"

"\n");

#define UNSIGNED_CHAR_CONVERTER_METHODDEF \

{"unsigned_char_converter", _PyCFunction_CAST(unsigned_char_converter), METH_FASTCALL, unsigned_char_converter__doc__},

static PyObject *

unsigned_char_converter_impl(PyObject *module, unsigned char a,

unsigned char b, unsigned char c);

static PyObject *

unsigned_char_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)

{

PyObject *return_value = NULL;

unsigned char a = 12;

unsigned char b = 34;

unsigned char c = 56;

if (!_PyArg_CheckPositional("unsigned_char_converter", nargs, 0, 3)) {

goto exit;

}

if (nargs < 1) {

goto skip_optional;

}

{

long ival = PyLong_AsLong(args[0]);

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

goto exit;

}

else if (ival < 0) {

PyErr_SetString(PyExc_OverflowError,

"unsigned byte integer is less than minimum");

goto exit;

}

else if (ival > UCHAR_MAX) {

PyErr_SetString(PyExc_OverflowError,

"unsigned byte integer is greater than maximum");

goto exit;

}

else {

a = (unsigned char) ival;

}

}

if (nargs < 2) {

goto skip_optional;

}

{

long ival = PyLong_AsLong(args[1]);

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

goto exit;

}

else if (ival < 0) {

PyErr_SetString(PyExc_OverflowError,

"unsigned byte integer is less than minimum");

goto exit;

}

else if (ival > UCHAR_MAX) {

PyErr_SetString(PyExc_OverflowError,

"unsigned byte integer is greater than maximum");

goto exit;

}

else {

b = (unsigned char) ival;

}

}

if (nargs < 3) {

goto skip_optional;

}

{

unsigned long ival = PyLong_AsUnsignedLongMask(args[2]);

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

goto exit;

}

else {

c = (unsigned char) ival;

}

}

skip_optional:

return_value = unsigned_char_converter_impl(module, a, b, c);

exit:

return return_value;

}

PyDoc_STRVAR(short_converter__doc__,

"short_converter($module, a=12, /)\n"

"--\n"

"\n");

#define SHORT_CONVERTER_METHODDEF \

{"short_converter", _PyCFunction_CAST(short_converter), METH_FASTCALL, short_converter__doc__},

static PyObject *

short_converter_impl(PyObject *module, short a);

static PyObject *

short_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)

{

PyObject *return_value = NULL;

short a = 12;

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

goto exit;

}

if (nargs < 1) {

goto skip_optional;

}

{

long ival = PyLong_AsLong(args[0]);

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

goto exit;

}

else if (ival < SHRT_MIN) {

PyErr_SetString(PyExc_OverflowError,

"signed short integer is less than minimum");

goto exit;

}

else if (ival > SHRT_MAX) {

PyErr_SetString(PyExc_OverflowError,

"signed short integer is greater than maximum");

goto exit;

}

else {

a = (short) ival;

}

}

skip_optional:

return_value = short_converter_impl(module, a);

exit:

return return_value;

}

PyDoc_STRVAR(unsigned_short_converter__doc__,

"unsigned_short_converter($module, a=12, b=34, c=56, /)\n"

"--\n"

"\n");

#define UNSIGNED_SHORT_CONVERTER_METHODDEF \

{"unsigned_short_converter", _PyCFunction_CAST(unsigned_short_converter), METH_FASTCALL, unsigned_short_converter__doc__},

static PyObject *

unsigned_short_converter_impl(PyObject *module, unsigned short a,

unsigned short b, unsigned short c);

static PyObject *

unsigned_short_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)

{

PyObject *return_value = NULL;

unsigned short a = 12;

unsigned short b = 34;

unsigned short c = 56;

if (!_PyArg_CheckPositional("unsigned_short_converter", nargs, 0, 3)) {

goto exit;

}

if (nargs < 1) {

goto skip_optional;

}

if (!_PyLong_UnsignedShort_Converter(args[0], &a)) {

goto exit;

}

if (nargs < 2) {

goto skip_optional;

}

if (!_PyLong_UnsignedShort_Converter(args[1], &b)) {

goto exit;

}

if (nargs < 3) {

goto skip_optional;

}

c = (unsigned short)PyLong_AsUnsignedLongMask(args[2]);

if (c == (unsigned short)-1 && PyErr_Occurred()) {

goto exit;

}

skip_optional:

return_value = unsigned_short_converter_impl(module, a, b, c);

exit:

return return_value;

}

PyDoc_STRVAR(int_converter__doc__,

"int_converter($module, a=12, b=34, c=45, /)\n"

"--\n"

"\n");

#define INT_CONVERTER_METHODDEF \

{"int_converter", _PyCFunction_CAST(int_converter), METH_FASTCALL, int_converter__doc__},

static PyObject *

int_converter_impl(PyObject *module, int a, int b, int c);

static PyObject *

int_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)

{

PyObject *return_value = NULL;

int a = 12;

int b = 34;

int c = 45;

if (!_PyArg_CheckPositional("int_converter", nargs, 0, 3)) {

goto exit;

}

if (nargs < 1) {

goto skip_optional;

}

a = PyLong_AsInt(args[0]);

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

goto exit;

}

if (nargs < 2) {

goto skip_optional;

}

b = PyLong_AsInt(args[1]);

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

goto exit;

}

if (nargs < 3) {

goto skip_optional;

}

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

_PyArg_BadArgument("int_converter", "argument 3", "a unicode character", args[2]);

goto exit;

}

if (PyUnicode_GET_LENGTH(args[2]) != 1) {

PyErr_Format(PyExc_TypeError,

"int_converter(): argument 3 must be a unicode character, "

"not a string of length %zd",

PyUnicode_GET_LENGTH(args[2]));

goto exit;

}

c = PyUnicode_READ_CHAR(args[2], 0);

skip_optional:

return_value = int_converter_impl(module, a, b, c);

exit:

return return_value;

}

PyDoc_STRVAR(unsigned_int_converter__doc__,

"unsigned_int_converter($module, a=12, b=34, c=56, /)\n"

"--\n"

"\n");

#define UNSIGNED_INT_CONVERTER_METHODDEF \

{"unsigned_int_converter", _PyCFunction_CAST(unsigned_int_converter), METH_FASTCALL, unsigned_int_converter__doc__},

static PyObject *

unsigned_int_converter_impl(PyObject *module, unsigned int a, unsigned int b,

unsigned int c);

static PyObject *

unsigned_int_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)

{

PyObject *return_value = NULL;

unsigned int a = 12;

unsigned int b = 34;

unsigned int c = 56;

if (!_PyArg_CheckPositional("unsigned_int_converter", nargs, 0, 3)) {

goto exit;

}

if (nargs < 1) {

goto skip_optional;

}

if (!_PyLong_UnsignedInt_Converter(args[0], &a)) {

goto exit;

}

if (nargs < 2) {

goto skip_optional;

}

if (!_PyLong_UnsignedInt_Converter(args[1], &b)) {

goto exit;

}

if (nargs < 3) {

goto skip_optional;

}

c = (unsigned int)PyLong_AsUnsignedLongMask(args[2]);

if (c == (unsigned int)-1 && PyErr_Occurred()) {

goto exit;

}

skip_optional:

return_value = unsigned_int_converter_impl(module, a, b, c);

exit:

return return_value;

}

PyDoc_STRVAR(long_converter__doc__,

"long_converter($module, a=12, /)\n"

"--\n"

"\n");

#define LONG_CONVERTER_METHODDEF \

{"long_converter", _PyCFunction_CAST(long_converter), METH_FASTCALL, long_converter__doc__},

static PyObject *

long_converter_impl(PyObject *module, long a);

static PyObject *

long_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)

{

PyObject *return_value = NULL;

long a = 12;

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

goto exit;

}

if (nargs < 1) {

goto skip_optional;

}

a = PyLong_AsLong(args[0]);

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

goto exit;

}

skip_optional:

return_value = long_converter_impl(module, a);

exit:

return return_value;

}

PyDoc_STRVAR(unsigned_long_converter__doc__,

"unsigned_long_converter($module, a=12, b=34, c=56, /)\n"

"--\n"

"\n");

#define UNSIGNED_LONG_CONVERTER_METHODDEF \

{"unsigned_long_converter", _PyCFunction_CAST(unsigned_long_converter), METH_FASTCALL, unsigned_long_converter__doc__},

static PyObject *

unsigned_long_converter_impl(PyObject *module, unsigned long a,

unsigned long b, unsigned long c);

static PyObject *

unsigned_long_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)

{

PyObject *return_value = NULL;

unsigned long a = 12;

unsigned long b = 34;

unsigned long c = 56;

if (!_PyArg_CheckPositional("unsigned_long_converter", nargs, 0, 3)) {

goto exit;

}

if (nargs < 1) {

goto skip_optional;

}

if (!_PyLong_UnsignedLong_Converter(args[0], &a)) {

goto exit;

}

if (nargs < 2) {

goto skip_optional;

}

if (!_PyLong_UnsignedLong_Converter(args[1], &b)) {

goto exit;

}

if (nargs < 3) {

goto skip_optional;

}

if (!PyLong_Check(args[2])) {

_PyArg_BadArgument("unsigned_long_converter", "argument 3", "int", args[2]);

goto exit;

}

c = PyLong_AsUnsignedLongMask(args[2]);

skip_optional:

return_value = unsigned_long_converter_impl(module, a, b, c);

exit:

return return_value;

}

PyDoc_STRVAR(long_long_converter__doc__,

"long_long_converter($module, a=12, /)\n"

"--\n"

"\n");

#define LONG_LONG_CONVERTER_METHODDEF \

{"long_long_converter", _PyCFunction_CAST(long_long_converter), METH_FASTCALL, long_long_converter__doc__},