/* Python wrapper functions auto-generated by pidl */
#define PY_SSIZE_T_CLEAN 1 /* We use Py_ssize_t for PyArg_ParseTupleAndKeywords */
#include <Python.h>
#include "python/py3compat.h"
#include "includes.h"
#include "python/modules.h"
#include <pytalloc.h>
#include "librpc/rpc/pyrpc.h"
#include "librpc/rpc/pyrpc_util.h"
#include "bin/default/librpc/gen_ndr/ndr_eventlog.h"
#include "bin/default/librpc/gen_ndr/ndr_eventlog_c.h"

/*
 * Suppress compiler warnings if the generated code does not call these
 * functions
 */
#ifndef _MAYBE_UNUSED_
#ifdef __has_attribute
#if __has_attribute(unused)
#define _MAYBE_UNUSED_ __attribute__ ((unused))
#else
#define _MAYBE_UNUSED_
#endif
#endif
#endif
/*
 * These functions are here to ensure they can be optimized out by
 * the compiler based on the constant input values
 */

static inline unsigned long long ndr_sizeof2uintmax(size_t var_size)
{
	switch (var_size) {
	case 8:
		return UINT64_MAX;
	case 4:
		return UINT32_MAX;
	case 2:
		return UINT16_MAX;
	case 1:
		return UINT8_MAX;
	}

	return 0;
}

static inline _MAYBE_UNUSED_ long long ndr_sizeof2intmax(size_t var_size)
{
	switch (var_size) {
	case 8:
		return INT64_MAX;
	case 4:
		return INT32_MAX;
	case 2:
		return INT16_MAX;
	case 1:
		return INT8_MAX;
	}

	return 0;
}

#include "librpc/gen_ndr/lsa.h"
#include "librpc/gen_ndr/security.h"
static PyTypeObject eventlog_OpenUnknown0_Type;
static PyTypeObject eventlog_Record_tdb_Type;
static PyTypeObject EVENTLOGHEADER_Type;
static PyTypeObject EVENTLOGRECORD_Type;
static PyTypeObject EVENTLOGEOF_Type;
static PyTypeObject EVENTLOG_EVT_FILE_Type;
static PyTypeObject EVENTLOG_FULL_INFORMATION_Type;
static PyTypeObject eventlog_InterfaceType;
static PyTypeObject eventlog_ClearEventLogW_Type;
static PyTypeObject eventlog_BackupEventLogW_Type;
static PyTypeObject eventlog_CloseEventLog_Type;
static PyTypeObject eventlog_DeregisterEventSource_Type;
static PyTypeObject eventlog_GetNumRecords_Type;
static PyTypeObject eventlog_GetOldestRecord_Type;
static PyTypeObject eventlog_OpenEventLogW_Type;
static PyTypeObject eventlog_RegisterEventSourceW_Type;
static PyTypeObject eventlog_OpenBackupEventLogW_Type;
static PyTypeObject eventlog_ReadEventLogW_Type;
static PyTypeObject eventlog_ReportEventW_Type;
static PyTypeObject eventlog_GetLogInformation_Type;
static PyTypeObject eventlog_FlushEventLog_Type;
static PyTypeObject eventlog_ReportEventAndSourceW_Type;

static PyTypeObject *BaseObject_Type;
static PyTypeObject *dom_sid_Type;
static PyTypeObject *policy_handle_Type;
static PyTypeObject *lsa_String_Type;
static PyTypeObject *ClientConnection_Type;
static PyTypeObject *ndr_syntax_id_Type;

static PyObject *py_eventlog_OpenUnknown0_get_unknown0(PyObject *obj, void *closure)
{
	struct eventlog_OpenUnknown0 *object = (struct eventlog_OpenUnknown0 *)pytalloc_get_ptr(obj);
	PyObject *py_unknown0;
	py_unknown0 = PyLong_FromLong((uint16_t)object->unknown0);
	return py_unknown0;
}

static int py_eventlog_OpenUnknown0_set_unknown0(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_OpenUnknown0 *object = (struct eventlog_OpenUnknown0 *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->unknown0");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->unknown0));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->unknown0 = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_OpenUnknown0_get_unknown1(PyObject *obj, void *closure)
{
	struct eventlog_OpenUnknown0 *object = (struct eventlog_OpenUnknown0 *)pytalloc_get_ptr(obj);
	PyObject *py_unknown1;
	py_unknown1 = PyLong_FromLong((uint16_t)object->unknown1);
	return py_unknown1;
}

static int py_eventlog_OpenUnknown0_set_unknown1(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_OpenUnknown0 *object = (struct eventlog_OpenUnknown0 *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->unknown1");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->unknown1));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->unknown1 = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyGetSetDef py_eventlog_OpenUnknown0_getsetters[] = {
	{
		.name = discard_const_p(char, "unknown0"),
		.get = py_eventlog_OpenUnknown0_get_unknown0,
		.set = py_eventlog_OpenUnknown0_set_unknown0,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint16")
	},
	{
		.name = discard_const_p(char, "unknown1"),
		.get = py_eventlog_OpenUnknown0_get_unknown1,
		.set = py_eventlog_OpenUnknown0_set_unknown1,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint16")
	},
	{ .name = NULL }
};

static PyObject *py_eventlog_OpenUnknown0_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct eventlog_OpenUnknown0, type);
}


static PyTypeObject eventlog_OpenUnknown0_Type = {
	PyVarObject_HEAD_INIT(NULL, 0)
	.tp_name = "eventlog.OpenUnknown0",
	.tp_getset = py_eventlog_OpenUnknown0_getsetters,
	.tp_methods = NULL,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_new = py_eventlog_OpenUnknown0_new,
};


static PyObject *py_eventlog_Record_tdb_get_size(PyObject *obj, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(obj);
	PyObject *py_size;
	py_size = PyLong_FromUnsignedLongLong((uint32_t)object->size);
	return py_size;
}

static int py_eventlog_Record_tdb_set_size(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->size");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->size));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->size = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_Record_tdb_get_reserved(PyObject *obj, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(obj);
	PyObject *py_reserved;
	if (object->reserved == NULL) {
		py_reserved = Py_None;
		Py_INCREF(py_reserved);
	} else {
		py_reserved = PyUnicode_Decode(object->reserved, strlen(object->reserved), "utf-8", "ignore");
	}
	return py_reserved;
}

static int py_eventlog_Record_tdb_set_reserved(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->reserved");
		return -1;
	}
	{
		const char *test_str;
		const char *talloc_str;
		PyObject *unicode = NULL;
		if (PyUnicode_Check(value)) {
			unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
			if (unicode == NULL) {
				PyErr_NoMemory();
				return -1;
			}
			test_str = PyBytes_AS_STRING(unicode);
		} else if (PyBytes_Check(value)) {
			test_str = PyBytes_AS_STRING(value);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
			return -1;
		}
		talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
		if (unicode != NULL) {
			Py_DECREF(unicode);
		}
		if (talloc_str == NULL) {
			PyErr_NoMemory();
			return -1;
		}
		object->reserved = talloc_str;
	}
	return 0;
}

static PyObject *py_eventlog_Record_tdb_get_record_number(PyObject *obj, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(obj);
	PyObject *py_record_number;
	py_record_number = PyLong_FromUnsignedLongLong((uint32_t)object->record_number);
	return py_record_number;
}

static int py_eventlog_Record_tdb_set_record_number(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->record_number");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->record_number));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->record_number = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_Record_tdb_get_time_generated(PyObject *obj, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(obj);
	PyObject *py_time_generated;
	py_time_generated = PyLong_FromLong(object->time_generated);
	return py_time_generated;
}

static int py_eventlog_Record_tdb_set_time_generated(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->time_generated");
		return -1;
	}
	{
		const long long int_max = ndr_sizeof2intmax(sizeof(object->time_generated));
		const long long int_min = -int_max - 1;
		if (PyLong_Check(value)) {
			long long test_var;
			test_var = PyLong_AsLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var < int_min || test_var > int_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range %lld - %lld, got %lld",\
				  PyLong_Type.tp_name, int_min, int_max, test_var);
				return -1;
			}
			object->time_generated = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_Record_tdb_get_time_written(PyObject *obj, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(obj);
	PyObject *py_time_written;
	py_time_written = PyLong_FromLong(object->time_written);
	return py_time_written;
}

static int py_eventlog_Record_tdb_set_time_written(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->time_written");
		return -1;
	}
	{
		const long long int_max = ndr_sizeof2intmax(sizeof(object->time_written));
		const long long int_min = -int_max - 1;
		if (PyLong_Check(value)) {
			long long test_var;
			test_var = PyLong_AsLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var < int_min || test_var > int_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range %lld - %lld, got %lld",\
				  PyLong_Type.tp_name, int_min, int_max, test_var);
				return -1;
			}
			object->time_written = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_Record_tdb_get_event_id(PyObject *obj, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(obj);
	PyObject *py_event_id;
	py_event_id = PyLong_FromUnsignedLongLong((uint32_t)object->event_id);
	return py_event_id;
}

static int py_eventlog_Record_tdb_set_event_id(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->event_id");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->event_id));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->event_id = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_Record_tdb_get_event_type(PyObject *obj, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(obj);
	PyObject *py_event_type;
	py_event_type = PyLong_FromLong((uint16_t)object->event_type);
	return py_event_type;
}

static int py_eventlog_Record_tdb_set_event_type(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->event_type");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->event_type));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->event_type = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_Record_tdb_get_num_of_strings(PyObject *obj, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(obj);
	PyObject *py_num_of_strings;
	py_num_of_strings = PyLong_FromLong((uint16_t)object->num_of_strings);
	return py_num_of_strings;
}

static int py_eventlog_Record_tdb_set_num_of_strings(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->num_of_strings");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->num_of_strings));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->num_of_strings = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_Record_tdb_get_event_category(PyObject *obj, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(obj);
	PyObject *py_event_category;
	py_event_category = PyLong_FromLong((uint16_t)object->event_category);
	return py_event_category;
}

static int py_eventlog_Record_tdb_set_event_category(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->event_category");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->event_category));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->event_category = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_Record_tdb_get_reserved_flags(PyObject *obj, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(obj);
	PyObject *py_reserved_flags;
	py_reserved_flags = PyLong_FromLong((uint16_t)object->reserved_flags);
	return py_reserved_flags;
}

static int py_eventlog_Record_tdb_set_reserved_flags(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->reserved_flags");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->reserved_flags));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->reserved_flags = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_Record_tdb_get_closing_record_number(PyObject *obj, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(obj);
	PyObject *py_closing_record_number;
	py_closing_record_number = PyLong_FromUnsignedLongLong((uint32_t)object->closing_record_number);
	return py_closing_record_number;
}

static int py_eventlog_Record_tdb_set_closing_record_number(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->closing_record_number");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->closing_record_number));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->closing_record_number = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_Record_tdb_get_stringoffset(PyObject *obj, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(obj);
	PyObject *py_stringoffset;
	py_stringoffset = PyLong_FromUnsignedLongLong((uint32_t)object->stringoffset);
	return py_stringoffset;
}

static int py_eventlog_Record_tdb_set_stringoffset(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->stringoffset");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->stringoffset));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->stringoffset = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_Record_tdb_get_sid_length(PyObject *obj, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(obj);
	PyObject *py_sid_length;
	py_sid_length = PyLong_FromUnsignedLongLong((uint32_t)object->sid_length);
	return py_sid_length;
}

static int py_eventlog_Record_tdb_set_sid_length(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->sid_length");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->sid_length));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->sid_length = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_Record_tdb_get_sid_offset(PyObject *obj, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(obj);
	PyObject *py_sid_offset;
	py_sid_offset = PyLong_FromUnsignedLongLong((uint32_t)object->sid_offset);
	return py_sid_offset;
}

static int py_eventlog_Record_tdb_set_sid_offset(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->sid_offset");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->sid_offset));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->sid_offset = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_Record_tdb_get_data_length(PyObject *obj, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(obj);
	PyObject *py_data_length;
	py_data_length = PyLong_FromUnsignedLongLong((uint32_t)object->data_length);
	return py_data_length;
}

static int py_eventlog_Record_tdb_set_data_length(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->data_length");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->data_length));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->data_length = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_Record_tdb_get_data_offset(PyObject *obj, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(obj);
	PyObject *py_data_offset;
	py_data_offset = PyLong_FromUnsignedLongLong((uint32_t)object->data_offset);
	return py_data_offset;
}

static int py_eventlog_Record_tdb_set_data_offset(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->data_offset");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->data_offset));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->data_offset = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_Record_tdb_get_source_name_len(PyObject *obj, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(obj);
	PyObject *py_source_name_len;
	py_source_name_len = PyLong_FromUnsignedLongLong((uint32_t)object->source_name_len);
	return py_source_name_len;
}

static int py_eventlog_Record_tdb_set_source_name_len(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->source_name_len");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->source_name_len));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->source_name_len = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_Record_tdb_get_source_name(PyObject *obj, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(obj);
	PyObject *py_source_name;
	py_source_name = PyString_FromStringOrNULL(object->source_name);
	return py_source_name;
}

static int py_eventlog_Record_tdb_set_source_name(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->source_name");
		return -1;
	}
	{
		const char *test_str;
		const char *talloc_str;
		PyObject *unicode = NULL;
		if (PyUnicode_Check(value)) {
			unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
			if (unicode == NULL) {
				PyErr_NoMemory();
				return -1;
			}
			test_str = PyBytes_AS_STRING(unicode);
		} else if (PyBytes_Check(value)) {
			test_str = PyBytes_AS_STRING(value);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
			return -1;
		}
		talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
		if (unicode != NULL) {
			Py_DECREF(unicode);
		}
		if (talloc_str == NULL) {
			PyErr_NoMemory();
			return -1;
		}
		object->source_name = talloc_str;
	}
	return 0;
}

static PyObject *py_eventlog_Record_tdb_get_computer_name_len(PyObject *obj, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(obj);
	PyObject *py_computer_name_len;
	py_computer_name_len = PyLong_FromUnsignedLongLong((uint32_t)object->computer_name_len);
	return py_computer_name_len;
}

static int py_eventlog_Record_tdb_set_computer_name_len(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->computer_name_len");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->computer_name_len));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->computer_name_len = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_Record_tdb_get_computer_name(PyObject *obj, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(obj);
	PyObject *py_computer_name;
	py_computer_name = PyString_FromStringOrNULL(object->computer_name);
	return py_computer_name;
}

static int py_eventlog_Record_tdb_set_computer_name(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->computer_name");
		return -1;
	}
	{
		const char *test_str;
		const char *talloc_str;
		PyObject *unicode = NULL;
		if (PyUnicode_Check(value)) {
			unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
			if (unicode == NULL) {
				PyErr_NoMemory();
				return -1;
			}
			test_str = PyBytes_AS_STRING(unicode);
		} else if (PyBytes_Check(value)) {
			test_str = PyBytes_AS_STRING(value);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
			return -1;
		}
		talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
		if (unicode != NULL) {
			Py_DECREF(unicode);
		}
		if (talloc_str == NULL) {
			PyErr_NoMemory();
			return -1;
		}
		object->computer_name = talloc_str;
	}
	return 0;
}

static PyObject *py_eventlog_Record_tdb_get_sid_padding(PyObject *obj, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(obj);
	PyObject *py_sid_padding;
	py_sid_padding = PyLong_FromUnsignedLongLong((uint32_t)object->sid_padding);
	return py_sid_padding;
}

static int py_eventlog_Record_tdb_set_sid_padding(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->sid_padding");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->sid_padding));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->sid_padding = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_Record_tdb_get_sid(PyObject *obj, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(obj);
	PyObject *py_sid;
	py_sid = PyBytes_FromStringAndSize((char *)(object->sid).data, (object->sid).length);
	return py_sid;
}

static int py_eventlog_Record_tdb_set_sid(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->sid");
		return -1;
	}
	object->sid = data_blob_talloc(pytalloc_get_mem_ctx(py_obj), PyBytes_AS_STRING(value), PyBytes_GET_SIZE(value));
	return 0;
}

static PyObject *py_eventlog_Record_tdb_get_strings_len(PyObject *obj, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(obj);
	PyObject *py_strings_len;
	py_strings_len = PyLong_FromUnsignedLongLong((uint32_t)object->strings_len);
	return py_strings_len;
}

static int py_eventlog_Record_tdb_set_strings_len(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->strings_len");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->strings_len));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->strings_len = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_Record_tdb_get_strings(PyObject *obj, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(obj);
	PyObject *py_strings;
	py_strings = PyList_New(object->num_of_strings);
	if (py_strings == NULL) {
		return NULL;
	}
	{
		int strings_cntr_0;
		for (strings_cntr_0 = 0; strings_cntr_0 < (object->num_of_strings); strings_cntr_0++) {
			PyObject *py_strings_0;
			py_strings_0 = PyString_FromStringOrNULL(object->strings[strings_cntr_0]);
			PyList_SetItem(py_strings, strings_cntr_0, py_strings_0);
		}
	}
	return py_strings;
}

static int py_eventlog_Record_tdb_set_strings(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->strings");
		return -1;
	}
	PY_CHECK_TYPE(&PyList_Type, value, return -1;);
	{
		int strings_cntr_0;
		object->strings = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->strings, PyList_GET_SIZE(value));
		if (!object->strings) { return -1;; }
		talloc_set_name_const(object->strings, "ARRAY: object->strings");
		for (strings_cntr_0 = 0; strings_cntr_0 < PyList_GET_SIZE(value); strings_cntr_0++) {
			if (PyList_GET_ITEM(value, strings_cntr_0) == NULL) {
				PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->strings[strings_cntr_0]");
				return -1;
			}
			{
				const char *test_str;
				const char *talloc_str;
				PyObject *unicode = NULL;
				if (PyUnicode_Check(PyList_GET_ITEM(value, strings_cntr_0))) {
					unicode = PyUnicode_AsEncodedString(PyList_GET_ITEM(value, strings_cntr_0), "utf-8", "ignore");
					if (unicode == NULL) {
						PyErr_NoMemory();
						return -1;
					}
					test_str = PyBytes_AS_STRING(unicode);
				} else if (PyBytes_Check(PyList_GET_ITEM(value, strings_cntr_0))) {
					test_str = PyBytes_AS_STRING(PyList_GET_ITEM(value, strings_cntr_0));
				} else {
					PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(PyList_GET_ITEM(value, strings_cntr_0))->tp_name);
					return -1;
				}
				talloc_str = talloc_strdup(object->strings, test_str);
				if (unicode != NULL) {
					Py_DECREF(unicode);
				}
				if (talloc_str == NULL) {
					PyErr_NoMemory();
					return -1;
				}
				object->strings[strings_cntr_0] = talloc_str;
			}
		}
	}
	return 0;
}

static PyObject *py_eventlog_Record_tdb_get_data(PyObject *obj, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(obj);
	PyObject *py_data;
	py_data = PyBytes_FromStringAndSize((char *)(object->data).data, (object->data).length);
	return py_data;
}

static int py_eventlog_Record_tdb_set_data(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->data");
		return -1;
	}
	object->data = data_blob_talloc(pytalloc_get_mem_ctx(py_obj), PyBytes_AS_STRING(value), PyBytes_GET_SIZE(value));
	return 0;
}

static PyObject *py_eventlog_Record_tdb_get_padding(PyObject *obj, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(obj);
	PyObject *py_padding;
	py_padding = PyLong_FromUnsignedLongLong((uint32_t)object->padding);
	return py_padding;
}

static int py_eventlog_Record_tdb_set_padding(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->padding");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->padding));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->padding = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyGetSetDef py_eventlog_Record_tdb_getsetters[] = {
	{
		.name = discard_const_p(char, "size"),
		.get = py_eventlog_Record_tdb_get_size,
		.set = py_eventlog_Record_tdb_set_size,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "reserved"),
		.get = py_eventlog_Record_tdb_get_reserved,
		.set = py_eventlog_Record_tdb_set_reserved,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint8")
	},
	{
		.name = discard_const_p(char, "record_number"),
		.get = py_eventlog_Record_tdb_get_record_number,
		.set = py_eventlog_Record_tdb_set_record_number,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "time_generated"),
		.get = py_eventlog_Record_tdb_get_time_generated,
		.set = py_eventlog_Record_tdb_set_time_generated,
		.doc = discard_const_p(char, "PIDL-generated element of base type time_t")
	},
	{
		.name = discard_const_p(char, "time_written"),
		.get = py_eventlog_Record_tdb_get_time_written,
		.set = py_eventlog_Record_tdb_set_time_written,
		.doc = discard_const_p(char, "PIDL-generated element of base type time_t")
	},
	{
		.name = discard_const_p(char, "event_id"),
		.get = py_eventlog_Record_tdb_get_event_id,
		.set = py_eventlog_Record_tdb_set_event_id,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "event_type"),
		.get = py_eventlog_Record_tdb_get_event_type,
		.set = py_eventlog_Record_tdb_set_event_type,
		.doc = discard_const_p(char, "PIDL-generated element of base type eventlogEventTypes")
	},
	{
		.name = discard_const_p(char, "num_of_strings"),
		.get = py_eventlog_Record_tdb_get_num_of_strings,
		.set = py_eventlog_Record_tdb_set_num_of_strings,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint16")
	},
	{
		.name = discard_const_p(char, "event_category"),
		.get = py_eventlog_Record_tdb_get_event_category,
		.set = py_eventlog_Record_tdb_set_event_category,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint16")
	},
	{
		.name = discard_const_p(char, "reserved_flags"),
		.get = py_eventlog_Record_tdb_get_reserved_flags,
		.set = py_eventlog_Record_tdb_set_reserved_flags,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint16")
	},
	{
		.name = discard_const_p(char, "closing_record_number"),
		.get = py_eventlog_Record_tdb_get_closing_record_number,
		.set = py_eventlog_Record_tdb_set_closing_record_number,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "stringoffset"),
		.get = py_eventlog_Record_tdb_get_stringoffset,
		.set = py_eventlog_Record_tdb_set_stringoffset,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "sid_length"),
		.get = py_eventlog_Record_tdb_get_sid_length,
		.set = py_eventlog_Record_tdb_set_sid_length,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "sid_offset"),
		.get = py_eventlog_Record_tdb_get_sid_offset,
		.set = py_eventlog_Record_tdb_set_sid_offset,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "data_length"),
		.get = py_eventlog_Record_tdb_get_data_length,
		.set = py_eventlog_Record_tdb_set_data_length,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "data_offset"),
		.get = py_eventlog_Record_tdb_get_data_offset,
		.set = py_eventlog_Record_tdb_set_data_offset,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "source_name_len"),
		.get = py_eventlog_Record_tdb_get_source_name_len,
		.set = py_eventlog_Record_tdb_set_source_name_len,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "source_name"),
		.get = py_eventlog_Record_tdb_get_source_name,
		.set = py_eventlog_Record_tdb_set_source_name,
		.doc = discard_const_p(char, "PIDL-generated element of base type string")
	},
	{
		.name = discard_const_p(char, "computer_name_len"),
		.get = py_eventlog_Record_tdb_get_computer_name_len,
		.set = py_eventlog_Record_tdb_set_computer_name_len,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "computer_name"),
		.get = py_eventlog_Record_tdb_get_computer_name,
		.set = py_eventlog_Record_tdb_set_computer_name,
		.doc = discard_const_p(char, "PIDL-generated element of base type string")
	},
	{
		.name = discard_const_p(char, "sid_padding"),
		.get = py_eventlog_Record_tdb_get_sid_padding,
		.set = py_eventlog_Record_tdb_set_sid_padding,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "sid"),
		.get = py_eventlog_Record_tdb_get_sid,
		.set = py_eventlog_Record_tdb_set_sid,
		.doc = discard_const_p(char, "PIDL-generated element of base type DATA_BLOB")
	},
	{
		.name = discard_const_p(char, "strings_len"),
		.get = py_eventlog_Record_tdb_get_strings_len,
		.set = py_eventlog_Record_tdb_set_strings_len,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "strings"),
		.get = py_eventlog_Record_tdb_get_strings,
		.set = py_eventlog_Record_tdb_set_strings,
		.doc = discard_const_p(char, "PIDL-generated element of base type string")
	},
	{
		.name = discard_const_p(char, "data"),
		.get = py_eventlog_Record_tdb_get_data,
		.set = py_eventlog_Record_tdb_set_data,
		.doc = discard_const_p(char, "PIDL-generated element of base type DATA_BLOB")
	},
	{
		.name = discard_const_p(char, "padding"),
		.get = py_eventlog_Record_tdb_get_padding,
		.set = py_eventlog_Record_tdb_set_padding,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{ .name = NULL }
};

static PyObject *py_eventlog_Record_tdb_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct eventlog_Record_tdb, type);
}

static PyObject *py_eventlog_Record_tdb_ndr_pack(PyObject *py_obj,  PyObject *Py_UNUSED(ignored))
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(py_obj);
	PyObject *ret = NULL;
	DATA_BLOB blob;
	enum ndr_err_code err;
	TALLOC_CTX *tmp_ctx = talloc_new(pytalloc_get_mem_ctx(py_obj));
	if (tmp_ctx == NULL) {
		PyErr_SetNdrError(NDR_ERR_ALLOC);
		return NULL;
	}
	err = ndr_push_struct_blob(&blob, tmp_ctx, object, (ndr_push_flags_fn_t)ndr_push_eventlog_Record_tdb);
	if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
		TALLOC_FREE(tmp_ctx);
		PyErr_SetNdrError(err);
		return NULL;
	}

	ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
	TALLOC_FREE(tmp_ctx);
	return ret;
}

static PyObject *py_eventlog_Record_tdb_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(py_obj);
	DATA_BLOB blob = {.data = NULL, .length = 0};
	Py_ssize_t blob_length = 0;
	enum ndr_err_code err;
	const char * const kwnames[] = { "data_blob", "allow_remaining", NULL };
	PyObject *allow_remaining_obj = NULL;
	bool allow_remaining = false;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|O:__ndr_unpack__",
		discard_const_p(char *, kwnames),
		&blob.data, &blob_length,
		&allow_remaining_obj)) {
		return NULL;
	}
	blob.length = blob_length;

	if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
		allow_remaining = true;
	}

	if (allow_remaining) {
		err = ndr_pull_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_eventlog_Record_tdb);
	} else {
		err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_eventlog_Record_tdb);
	}
	if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
		PyErr_SetNdrError(err);
		return NULL;
	}

	Py_RETURN_NONE;
}

static PyObject *py_eventlog_Record_tdb_ndr_print(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
{
	struct eventlog_Record_tdb *object = (struct eventlog_Record_tdb *)pytalloc_get_ptr(py_obj);
	PyObject *ret;
	char *retstr;

	retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_eventlog_Record_tdb, "eventlog_Record_tdb", object);
	ret = PyUnicode_FromString(retstr);
	talloc_free(retstr);

	return ret;
}

static PyMethodDef py_eventlog_Record_tdb_methods[] = {
	{ "__ndr_pack__", (PyCFunction)py_eventlog_Record_tdb_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
	{ "__ndr_unpack__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_Record_tdb_ndr_unpack), METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack(class, blob, allow_remaining=False) -> None\nNDR unpack" },
	{ "__ndr_print__", (PyCFunction)py_eventlog_Record_tdb_ndr_print, METH_NOARGS, "S.ndr_print(object) -> None\nNDR print" },
	{ NULL, NULL, 0, NULL }
};


static PyTypeObject eventlog_Record_tdb_Type = {
	PyVarObject_HEAD_INIT(NULL, 0)
	.tp_name = "eventlog.Record_tdb",
	.tp_getset = py_eventlog_Record_tdb_getsetters,
	.tp_methods = py_eventlog_Record_tdb_methods,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_new = py_eventlog_Record_tdb_new,
};


static PyObject *py_EVENTLOGHEADER_get_HeaderSize(PyObject *obj, void *closure)
{
	struct EVENTLOGHEADER *object = (struct EVENTLOGHEADER *)pytalloc_get_ptr(obj);
	PyObject *py_HeaderSize;
	py_HeaderSize = PyLong_FromUnsignedLongLong((uint32_t)object->HeaderSize);
	return py_HeaderSize;
}

static int py_EVENTLOGHEADER_set_HeaderSize(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOGHEADER *object = (struct EVENTLOGHEADER *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->HeaderSize");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->HeaderSize));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->HeaderSize = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_EVENTLOGHEADER_get_Signature(PyObject *obj, void *closure)
{
	struct EVENTLOGHEADER *object = (struct EVENTLOGHEADER *)pytalloc_get_ptr(obj);
	PyObject *py_Signature;
	if (object->Signature == NULL) {
		py_Signature = Py_None;
		Py_INCREF(py_Signature);
	} else {
		py_Signature = PyUnicode_Decode(object->Signature, strlen(object->Signature), "utf-8", "ignore");
	}
	return py_Signature;
}

static int py_EVENTLOGHEADER_set_Signature(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOGHEADER *object = (struct EVENTLOGHEADER *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->Signature");
		return -1;
	}
	{
		const char *test_str;
		const char *talloc_str;
		PyObject *unicode = NULL;
		if (PyUnicode_Check(value)) {
			unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
			if (unicode == NULL) {
				PyErr_NoMemory();
				return -1;
			}
			test_str = PyBytes_AS_STRING(unicode);
		} else if (PyBytes_Check(value)) {
			test_str = PyBytes_AS_STRING(value);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
			return -1;
		}
		talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
		if (unicode != NULL) {
			Py_DECREF(unicode);
		}
		if (talloc_str == NULL) {
			PyErr_NoMemory();
			return -1;
		}
		object->Signature = talloc_str;
	}
	return 0;
}

static PyObject *py_EVENTLOGHEADER_get_MajorVersion(PyObject *obj, void *closure)
{
	struct EVENTLOGHEADER *object = (struct EVENTLOGHEADER *)pytalloc_get_ptr(obj);
	PyObject *py_MajorVersion;
	py_MajorVersion = PyLong_FromUnsignedLongLong((uint32_t)object->MajorVersion);
	return py_MajorVersion;
}

static int py_EVENTLOGHEADER_set_MajorVersion(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOGHEADER *object = (struct EVENTLOGHEADER *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->MajorVersion");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->MajorVersion));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->MajorVersion = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_EVENTLOGHEADER_get_MinorVersion(PyObject *obj, void *closure)
{
	struct EVENTLOGHEADER *object = (struct EVENTLOGHEADER *)pytalloc_get_ptr(obj);
	PyObject *py_MinorVersion;
	py_MinorVersion = PyLong_FromUnsignedLongLong((uint32_t)object->MinorVersion);
	return py_MinorVersion;
}

static int py_EVENTLOGHEADER_set_MinorVersion(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOGHEADER *object = (struct EVENTLOGHEADER *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->MinorVersion");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->MinorVersion));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->MinorVersion = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_EVENTLOGHEADER_get_StartOffset(PyObject *obj, void *closure)
{
	struct EVENTLOGHEADER *object = (struct EVENTLOGHEADER *)pytalloc_get_ptr(obj);
	PyObject *py_StartOffset;
	py_StartOffset = PyLong_FromUnsignedLongLong((uint32_t)object->StartOffset);
	return py_StartOffset;
}

static int py_EVENTLOGHEADER_set_StartOffset(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOGHEADER *object = (struct EVENTLOGHEADER *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->StartOffset");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->StartOffset));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->StartOffset = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_EVENTLOGHEADER_get_EndOffset(PyObject *obj, void *closure)
{
	struct EVENTLOGHEADER *object = (struct EVENTLOGHEADER *)pytalloc_get_ptr(obj);
	PyObject *py_EndOffset;
	py_EndOffset = PyLong_FromUnsignedLongLong((uint32_t)object->EndOffset);
	return py_EndOffset;
}

static int py_EVENTLOGHEADER_set_EndOffset(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOGHEADER *object = (struct EVENTLOGHEADER *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->EndOffset");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->EndOffset));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->EndOffset = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_EVENTLOGHEADER_get_CurrentRecordNumber(PyObject *obj, void *closure)
{
	struct EVENTLOGHEADER *object = (struct EVENTLOGHEADER *)pytalloc_get_ptr(obj);
	PyObject *py_CurrentRecordNumber;
	py_CurrentRecordNumber = PyLong_FromUnsignedLongLong((uint32_t)object->CurrentRecordNumber);
	return py_CurrentRecordNumber;
}

static int py_EVENTLOGHEADER_set_CurrentRecordNumber(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOGHEADER *object = (struct EVENTLOGHEADER *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->CurrentRecordNumber");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->CurrentRecordNumber));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->CurrentRecordNumber = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_EVENTLOGHEADER_get_OldestRecordNumber(PyObject *obj, void *closure)
{
	struct EVENTLOGHEADER *object = (struct EVENTLOGHEADER *)pytalloc_get_ptr(obj);
	PyObject *py_OldestRecordNumber;
	py_OldestRecordNumber = PyLong_FromUnsignedLongLong((uint32_t)object->OldestRecordNumber);
	return py_OldestRecordNumber;
}

static int py_EVENTLOGHEADER_set_OldestRecordNumber(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOGHEADER *object = (struct EVENTLOGHEADER *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->OldestRecordNumber");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->OldestRecordNumber));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->OldestRecordNumber = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_EVENTLOGHEADER_get_MaxSize(PyObject *obj, void *closure)
{
	struct EVENTLOGHEADER *object = (struct EVENTLOGHEADER *)pytalloc_get_ptr(obj);
	PyObject *py_MaxSize;
	py_MaxSize = PyLong_FromUnsignedLongLong((uint32_t)object->MaxSize);
	return py_MaxSize;
}

static int py_EVENTLOGHEADER_set_MaxSize(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOGHEADER *object = (struct EVENTLOGHEADER *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->MaxSize");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->MaxSize));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->MaxSize = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_EVENTLOGHEADER_get_Flags(PyObject *obj, void *closure)
{
	struct EVENTLOGHEADER *object = (struct EVENTLOGHEADER *)pytalloc_get_ptr(obj);
	PyObject *py_Flags;
	py_Flags = PyLong_FromUnsignedLongLong((uint32_t)object->Flags);
	return py_Flags;
}

static int py_EVENTLOGHEADER_set_Flags(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOGHEADER *object = (struct EVENTLOGHEADER *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->Flags");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->Flags));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->Flags = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_EVENTLOGHEADER_get_Retention(PyObject *obj, void *closure)
{
	struct EVENTLOGHEADER *object = (struct EVENTLOGHEADER *)pytalloc_get_ptr(obj);
	PyObject *py_Retention;
	py_Retention = PyLong_FromUnsignedLongLong((uint32_t)object->Retention);
	return py_Retention;
}

static int py_EVENTLOGHEADER_set_Retention(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOGHEADER *object = (struct EVENTLOGHEADER *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->Retention");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->Retention));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->Retention = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_EVENTLOGHEADER_get_EndHeaderSize(PyObject *obj, void *closure)
{
	struct EVENTLOGHEADER *object = (struct EVENTLOGHEADER *)pytalloc_get_ptr(obj);
	PyObject *py_EndHeaderSize;
	py_EndHeaderSize = PyLong_FromUnsignedLongLong((uint32_t)object->EndHeaderSize);
	return py_EndHeaderSize;
}

static int py_EVENTLOGHEADER_set_EndHeaderSize(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOGHEADER *object = (struct EVENTLOGHEADER *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->EndHeaderSize");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->EndHeaderSize));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->EndHeaderSize = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyGetSetDef py_EVENTLOGHEADER_getsetters[] = {
	{
		.name = discard_const_p(char, "HeaderSize"),
		.get = py_EVENTLOGHEADER_get_HeaderSize,
		.set = py_EVENTLOGHEADER_set_HeaderSize,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "Signature"),
		.get = py_EVENTLOGHEADER_get_Signature,
		.set = py_EVENTLOGHEADER_set_Signature,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint8")
	},
	{
		.name = discard_const_p(char, "MajorVersion"),
		.get = py_EVENTLOGHEADER_get_MajorVersion,
		.set = py_EVENTLOGHEADER_set_MajorVersion,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "MinorVersion"),
		.get = py_EVENTLOGHEADER_get_MinorVersion,
		.set = py_EVENTLOGHEADER_set_MinorVersion,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "StartOffset"),
		.get = py_EVENTLOGHEADER_get_StartOffset,
		.set = py_EVENTLOGHEADER_set_StartOffset,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "EndOffset"),
		.get = py_EVENTLOGHEADER_get_EndOffset,
		.set = py_EVENTLOGHEADER_set_EndOffset,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "CurrentRecordNumber"),
		.get = py_EVENTLOGHEADER_get_CurrentRecordNumber,
		.set = py_EVENTLOGHEADER_set_CurrentRecordNumber,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "OldestRecordNumber"),
		.get = py_EVENTLOGHEADER_get_OldestRecordNumber,
		.set = py_EVENTLOGHEADER_set_OldestRecordNumber,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "MaxSize"),
		.get = py_EVENTLOGHEADER_get_MaxSize,
		.set = py_EVENTLOGHEADER_set_MaxSize,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "Flags"),
		.get = py_EVENTLOGHEADER_get_Flags,
		.set = py_EVENTLOGHEADER_set_Flags,
		.doc = discard_const_p(char, "PIDL-generated element of base type EVENTLOG_HEADER_FLAGS")
	},
	{
		.name = discard_const_p(char, "Retention"),
		.get = py_EVENTLOGHEADER_get_Retention,
		.set = py_EVENTLOGHEADER_set_Retention,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "EndHeaderSize"),
		.get = py_EVENTLOGHEADER_get_EndHeaderSize,
		.set = py_EVENTLOGHEADER_set_EndHeaderSize,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{ .name = NULL }
};

static PyObject *py_EVENTLOGHEADER_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct EVENTLOGHEADER, type);
}

static PyObject *py_EVENTLOGHEADER_ndr_pack(PyObject *py_obj,  PyObject *Py_UNUSED(ignored))
{
	struct EVENTLOGHEADER *object = (struct EVENTLOGHEADER *)pytalloc_get_ptr(py_obj);
	PyObject *ret = NULL;
	DATA_BLOB blob;
	enum ndr_err_code err;
	TALLOC_CTX *tmp_ctx = talloc_new(pytalloc_get_mem_ctx(py_obj));
	if (tmp_ctx == NULL) {
		PyErr_SetNdrError(NDR_ERR_ALLOC);
		return NULL;
	}
	err = ndr_push_struct_blob(&blob, tmp_ctx, object, (ndr_push_flags_fn_t)ndr_push_EVENTLOGHEADER);
	if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
		TALLOC_FREE(tmp_ctx);
		PyErr_SetNdrError(err);
		return NULL;
	}

	ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
	TALLOC_FREE(tmp_ctx);
	return ret;
}

static PyObject *py_EVENTLOGHEADER_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	struct EVENTLOGHEADER *object = (struct EVENTLOGHEADER *)pytalloc_get_ptr(py_obj);
	DATA_BLOB blob = {.data = NULL, .length = 0};
	Py_ssize_t blob_length = 0;
	enum ndr_err_code err;
	const char * const kwnames[] = { "data_blob", "allow_remaining", NULL };
	PyObject *allow_remaining_obj = NULL;
	bool allow_remaining = false;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|O:__ndr_unpack__",
		discard_const_p(char *, kwnames),
		&blob.data, &blob_length,
		&allow_remaining_obj)) {
		return NULL;
	}
	blob.length = blob_length;

	if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
		allow_remaining = true;
	}

	if (allow_remaining) {
		err = ndr_pull_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_EVENTLOGHEADER);
	} else {
		err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_EVENTLOGHEADER);
	}
	if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
		PyErr_SetNdrError(err);
		return NULL;
	}

	Py_RETURN_NONE;
}

static PyObject *py_EVENTLOGHEADER_ndr_print(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
{
	struct EVENTLOGHEADER *object = (struct EVENTLOGHEADER *)pytalloc_get_ptr(py_obj);
	PyObject *ret;
	char *retstr;

	retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_EVENTLOGHEADER, "EVENTLOGHEADER", object);
	ret = PyUnicode_FromString(retstr);
	talloc_free(retstr);

	return ret;
}

static PyMethodDef py_EVENTLOGHEADER_methods[] = {
	{ "__ndr_pack__", (PyCFunction)py_EVENTLOGHEADER_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
	{ "__ndr_unpack__", PY_DISCARD_FUNC_SIG(PyCFunction,py_EVENTLOGHEADER_ndr_unpack), METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack(class, blob, allow_remaining=False) -> None\nNDR unpack" },
	{ "__ndr_print__", (PyCFunction)py_EVENTLOGHEADER_ndr_print, METH_NOARGS, "S.ndr_print(object) -> None\nNDR print" },
	{ NULL, NULL, 0, NULL }
};


static PyTypeObject EVENTLOGHEADER_Type = {
	PyVarObject_HEAD_INIT(NULL, 0)
	.tp_name = "eventlog.EVENTLOGHEADER",
	.tp_getset = py_EVENTLOGHEADER_getsetters,
	.tp_methods = py_EVENTLOGHEADER_methods,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_new = py_EVENTLOGHEADER_new,
};


static PyObject *py_EVENTLOGRECORD_get_Length(PyObject *obj, void *closure)
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(obj);
	PyObject *py_Length;
	py_Length = PyLong_FromUnsignedLongLong((uint32_t)object->Length);
	return py_Length;
}

static int py_EVENTLOGRECORD_set_Length(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->Length");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->Length));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->Length = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_EVENTLOGRECORD_get_Reserved(PyObject *obj, void *closure)
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(obj);
	PyObject *py_Reserved;
	if (object->Reserved == NULL) {
		py_Reserved = Py_None;
		Py_INCREF(py_Reserved);
	} else {
		py_Reserved = PyUnicode_Decode(object->Reserved, strlen(object->Reserved), "utf-8", "ignore");
	}
	return py_Reserved;
}

static int py_EVENTLOGRECORD_set_Reserved(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->Reserved");
		return -1;
	}
	{
		const char *test_str;
		const char *talloc_str;
		PyObject *unicode = NULL;
		if (PyUnicode_Check(value)) {
			unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
			if (unicode == NULL) {
				PyErr_NoMemory();
				return -1;
			}
			test_str = PyBytes_AS_STRING(unicode);
		} else if (PyBytes_Check(value)) {
			test_str = PyBytes_AS_STRING(value);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
			return -1;
		}
		talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
		if (unicode != NULL) {
			Py_DECREF(unicode);
		}
		if (talloc_str == NULL) {
			PyErr_NoMemory();
			return -1;
		}
		object->Reserved = talloc_str;
	}
	return 0;
}

static PyObject *py_EVENTLOGRECORD_get_RecordNumber(PyObject *obj, void *closure)
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(obj);
	PyObject *py_RecordNumber;
	py_RecordNumber = PyLong_FromUnsignedLongLong((uint32_t)object->RecordNumber);
	return py_RecordNumber;
}

static int py_EVENTLOGRECORD_set_RecordNumber(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->RecordNumber");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->RecordNumber));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->RecordNumber = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_EVENTLOGRECORD_get_TimeGenerated(PyObject *obj, void *closure)
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(obj);
	PyObject *py_TimeGenerated;
	py_TimeGenerated = PyLong_FromLong(object->TimeGenerated);
	return py_TimeGenerated;
}

static int py_EVENTLOGRECORD_set_TimeGenerated(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->TimeGenerated");
		return -1;
	}
	{
		const long long int_max = ndr_sizeof2intmax(sizeof(object->TimeGenerated));
		const long long int_min = -int_max - 1;
		if (PyLong_Check(value)) {
			long long test_var;
			test_var = PyLong_AsLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var < int_min || test_var > int_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range %lld - %lld, got %lld",\
				  PyLong_Type.tp_name, int_min, int_max, test_var);
				return -1;
			}
			object->TimeGenerated = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_EVENTLOGRECORD_get_TimeWritten(PyObject *obj, void *closure)
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(obj);
	PyObject *py_TimeWritten;
	py_TimeWritten = PyLong_FromLong(object->TimeWritten);
	return py_TimeWritten;
}

static int py_EVENTLOGRECORD_set_TimeWritten(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->TimeWritten");
		return -1;
	}
	{
		const long long int_max = ndr_sizeof2intmax(sizeof(object->TimeWritten));
		const long long int_min = -int_max - 1;
		if (PyLong_Check(value)) {
			long long test_var;
			test_var = PyLong_AsLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var < int_min || test_var > int_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range %lld - %lld, got %lld",\
				  PyLong_Type.tp_name, int_min, int_max, test_var);
				return -1;
			}
			object->TimeWritten = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_EVENTLOGRECORD_get_EventID(PyObject *obj, void *closure)
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(obj);
	PyObject *py_EventID;
	py_EventID = PyLong_FromUnsignedLongLong((uint32_t)object->EventID);
	return py_EventID;
}

static int py_EVENTLOGRECORD_set_EventID(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->EventID");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->EventID));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->EventID = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_EVENTLOGRECORD_get_EventType(PyObject *obj, void *closure)
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(obj);
	PyObject *py_EventType;
	py_EventType = PyLong_FromLong((uint16_t)object->EventType);
	return py_EventType;
}

static int py_EVENTLOGRECORD_set_EventType(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->EventType");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->EventType));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->EventType = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_EVENTLOGRECORD_get_NumStrings(PyObject *obj, void *closure)
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(obj);
	PyObject *py_NumStrings;
	py_NumStrings = PyLong_FromLong((uint16_t)object->NumStrings);
	return py_NumStrings;
}

static int py_EVENTLOGRECORD_set_NumStrings(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->NumStrings");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->NumStrings));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->NumStrings = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_EVENTLOGRECORD_get_EventCategory(PyObject *obj, void *closure)
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(obj);
	PyObject *py_EventCategory;
	py_EventCategory = PyLong_FromLong((uint16_t)object->EventCategory);
	return py_EventCategory;
}

static int py_EVENTLOGRECORD_set_EventCategory(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->EventCategory");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->EventCategory));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->EventCategory = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_EVENTLOGRECORD_get_ReservedFlags(PyObject *obj, void *closure)
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(obj);
	PyObject *py_ReservedFlags;
	py_ReservedFlags = PyLong_FromLong((uint16_t)object->ReservedFlags);
	return py_ReservedFlags;
}

static int py_EVENTLOGRECORD_set_ReservedFlags(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->ReservedFlags");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->ReservedFlags));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->ReservedFlags = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_EVENTLOGRECORD_get_ClosingRecordNumber(PyObject *obj, void *closure)
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(obj);
	PyObject *py_ClosingRecordNumber;
	py_ClosingRecordNumber = PyLong_FromUnsignedLongLong((uint32_t)object->ClosingRecordNumber);
	return py_ClosingRecordNumber;
}

static int py_EVENTLOGRECORD_set_ClosingRecordNumber(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->ClosingRecordNumber");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->ClosingRecordNumber));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->ClosingRecordNumber = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_EVENTLOGRECORD_get_StringOffset(PyObject *obj, void *closure)
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(obj);
	PyObject *py_StringOffset;
	py_StringOffset = PyLong_FromUnsignedLongLong((uint32_t)object->StringOffset);
	return py_StringOffset;
}

static int py_EVENTLOGRECORD_set_StringOffset(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->StringOffset");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->StringOffset));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->StringOffset = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_EVENTLOGRECORD_get_UserSidLength(PyObject *obj, void *closure)
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(obj);
	PyObject *py_UserSidLength;
	py_UserSidLength = PyLong_FromUnsignedLongLong((uint32_t)object->UserSidLength);
	return py_UserSidLength;
}

static int py_EVENTLOGRECORD_set_UserSidLength(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->UserSidLength");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->UserSidLength));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->UserSidLength = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_EVENTLOGRECORD_get_UserSidOffset(PyObject *obj, void *closure)
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(obj);
	PyObject *py_UserSidOffset;
	py_UserSidOffset = PyLong_FromUnsignedLongLong((uint32_t)object->UserSidOffset);
	return py_UserSidOffset;
}

static int py_EVENTLOGRECORD_set_UserSidOffset(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->UserSidOffset");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->UserSidOffset));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->UserSidOffset = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_EVENTLOGRECORD_get_DataLength(PyObject *obj, void *closure)
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(obj);
	PyObject *py_DataLength;
	py_DataLength = PyLong_FromUnsignedLongLong((uint32_t)object->DataLength);
	return py_DataLength;
}

static int py_EVENTLOGRECORD_set_DataLength(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->DataLength");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->DataLength));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->DataLength = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_EVENTLOGRECORD_get_DataOffset(PyObject *obj, void *closure)
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(obj);
	PyObject *py_DataOffset;
	py_DataOffset = PyLong_FromUnsignedLongLong((uint32_t)object->DataOffset);
	return py_DataOffset;
}

static int py_EVENTLOGRECORD_set_DataOffset(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->DataOffset");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->DataOffset));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->DataOffset = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_EVENTLOGRECORD_get_SourceName(PyObject *obj, void *closure)
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(obj);
	PyObject *py_SourceName;
	py_SourceName = PyString_FromStringOrNULL(object->SourceName);
	return py_SourceName;
}

static int py_EVENTLOGRECORD_set_SourceName(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->SourceName");
		return -1;
	}
	{
		const char *test_str;
		const char *talloc_str;
		PyObject *unicode = NULL;
		if (PyUnicode_Check(value)) {
			unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
			if (unicode == NULL) {
				PyErr_NoMemory();
				return -1;
			}
			test_str = PyBytes_AS_STRING(unicode);
		} else if (PyBytes_Check(value)) {
			test_str = PyBytes_AS_STRING(value);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
			return -1;
		}
		talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
		if (unicode != NULL) {
			Py_DECREF(unicode);
		}
		if (talloc_str == NULL) {
			PyErr_NoMemory();
			return -1;
		}
		object->SourceName = talloc_str;
	}
	return 0;
}

static PyObject *py_EVENTLOGRECORD_get_Computername(PyObject *obj, void *closure)
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(obj);
	PyObject *py_Computername;
	py_Computername = PyString_FromStringOrNULL(object->Computername);
	return py_Computername;
}

static int py_EVENTLOGRECORD_set_Computername(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->Computername");
		return -1;
	}
	{
		const char *test_str;
		const char *talloc_str;
		PyObject *unicode = NULL;
		if (PyUnicode_Check(value)) {
			unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
			if (unicode == NULL) {
				PyErr_NoMemory();
				return -1;
			}
			test_str = PyBytes_AS_STRING(unicode);
		} else if (PyBytes_Check(value)) {
			test_str = PyBytes_AS_STRING(value);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
			return -1;
		}
		talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
		if (unicode != NULL) {
			Py_DECREF(unicode);
		}
		if (talloc_str == NULL) {
			PyErr_NoMemory();
			return -1;
		}
		object->Computername = talloc_str;
	}
	return 0;
}

static PyObject *py_EVENTLOGRECORD_get_UserSid(PyObject *obj, void *closure)
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(obj);
	PyObject *py_UserSid;
	py_UserSid = pytalloc_reference_ex(dom_sid_Type, pytalloc_get_mem_ctx(obj), &object->UserSid);
	return py_UserSid;
}

static int py_EVENTLOGRECORD_set_UserSid(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->UserSid");
		return -1;
	}
	PY_CHECK_TYPE(dom_sid_Type, value, return -1;);
	if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	object->UserSid = *(struct dom_sid *)pytalloc_get_ptr(value);
	return 0;
}

static PyObject *py_EVENTLOGRECORD_get_Strings(PyObject *obj, void *closure)
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(obj);
	PyObject *py_Strings;
	py_Strings = PyList_New(object->NumStrings);
	if (py_Strings == NULL) {
		return NULL;
	}
	{
		int Strings_cntr_0;
		for (Strings_cntr_0 = 0; Strings_cntr_0 < (object->NumStrings); Strings_cntr_0++) {
			PyObject *py_Strings_0;
			py_Strings_0 = PyString_FromStringOrNULL(object->Strings[Strings_cntr_0]);
			PyList_SetItem(py_Strings, Strings_cntr_0, py_Strings_0);
		}
	}
	return py_Strings;
}

static int py_EVENTLOGRECORD_set_Strings(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->Strings");
		return -1;
	}
	PY_CHECK_TYPE(&PyList_Type, value, return -1;);
	{
		int Strings_cntr_0;
		object->Strings = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->Strings, PyList_GET_SIZE(value));
		if (!object->Strings) { return -1;; }
		talloc_set_name_const(object->Strings, "ARRAY: object->Strings");
		for (Strings_cntr_0 = 0; Strings_cntr_0 < PyList_GET_SIZE(value); Strings_cntr_0++) {
			if (PyList_GET_ITEM(value, Strings_cntr_0) == NULL) {
				PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->Strings[Strings_cntr_0]");
				return -1;
			}
			{
				const char *test_str;
				const char *talloc_str;
				PyObject *unicode = NULL;
				if (PyUnicode_Check(PyList_GET_ITEM(value, Strings_cntr_0))) {
					unicode = PyUnicode_AsEncodedString(PyList_GET_ITEM(value, Strings_cntr_0), "utf-8", "ignore");
					if (unicode == NULL) {
						PyErr_NoMemory();
						return -1;
					}
					test_str = PyBytes_AS_STRING(unicode);
				} else if (PyBytes_Check(PyList_GET_ITEM(value, Strings_cntr_0))) {
					test_str = PyBytes_AS_STRING(PyList_GET_ITEM(value, Strings_cntr_0));
				} else {
					PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(PyList_GET_ITEM(value, Strings_cntr_0))->tp_name);
					return -1;
				}
				talloc_str = talloc_strdup(object->Strings, test_str);
				if (unicode != NULL) {
					Py_DECREF(unicode);
				}
				if (talloc_str == NULL) {
					PyErr_NoMemory();
					return -1;
				}
				object->Strings[Strings_cntr_0] = talloc_str;
			}
		}
	}
	return 0;
}

static PyObject *py_EVENTLOGRECORD_get_Data(PyObject *obj, void *closure)
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(obj);
	PyObject *py_Data;
	py_Data = PyList_New(object->DataLength);
	if (py_Data == NULL) {
		return NULL;
	}
	{
		int Data_cntr_0;
		for (Data_cntr_0 = 0; Data_cntr_0 < (object->DataLength); Data_cntr_0++) {
			PyObject *py_Data_0;
			py_Data_0 = PyLong_FromLong((uint16_t)object->Data[Data_cntr_0]);
			PyList_SetItem(py_Data, Data_cntr_0, py_Data_0);
		}
	}
	return py_Data;
}

static int py_EVENTLOGRECORD_set_Data(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->Data");
		return -1;
	}
	PY_CHECK_TYPE(&PyList_Type, value, return -1;);
	{
		int Data_cntr_0;
		object->Data = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->Data, PyList_GET_SIZE(value));
		if (!object->Data) { return -1;; }
		talloc_set_name_const(object->Data, "ARRAY: object->Data");
		for (Data_cntr_0 = 0; Data_cntr_0 < PyList_GET_SIZE(value); Data_cntr_0++) {
			if (PyList_GET_ITEM(value, Data_cntr_0) == NULL) {
				PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->Data[Data_cntr_0]");
				return -1;
			}
			{
				const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->Data[Data_cntr_0]));
				if (PyLong_Check(PyList_GET_ITEM(value, Data_cntr_0))) {
					unsigned long long test_var;
					test_var = PyLong_AsUnsignedLongLong(PyList_GET_ITEM(value, Data_cntr_0));
					if (PyErr_Occurred() != NULL) {
						return -1;
					}
					if (test_var > uint_max) {
						PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
						  PyLong_Type.tp_name, uint_max, test_var);
						return -1;
					}
					object->Data[Data_cntr_0] = test_var;
				} else {
					PyErr_Format(PyExc_TypeError, "Expected type %s",\
					  PyLong_Type.tp_name);
					return -1;
				}
			}
		}
	}
	return 0;
}

static PyObject *py_EVENTLOGRECORD_get_Pad(PyObject *obj, void *closure)
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(obj);
	PyObject *py_Pad;
	py_Pad = PyString_FromStringOrNULL(object->Pad);
	return py_Pad;
}

static int py_EVENTLOGRECORD_set_Pad(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->Pad");
		return -1;
	}
	{
		const char *test_str;
		const char *talloc_str;
		PyObject *unicode = NULL;
		if (PyUnicode_Check(value)) {
			unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
			if (unicode == NULL) {
				PyErr_NoMemory();
				return -1;
			}
			test_str = PyBytes_AS_STRING(unicode);
		} else if (PyBytes_Check(value)) {
			test_str = PyBytes_AS_STRING(value);
		} else {
			PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
			return -1;
		}
		talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
		if (unicode != NULL) {
			Py_DECREF(unicode);
		}
		if (talloc_str == NULL) {
			PyErr_NoMemory();
			return -1;
		}
		object->Pad = talloc_str;
	}
	return 0;
}

static PyObject *py_EVENTLOGRECORD_get_Length2(PyObject *obj, void *closure)
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(obj);
	PyObject *py_Length2;
	py_Length2 = PyLong_FromUnsignedLongLong((uint32_t)object->Length2);
	return py_Length2;
}

static int py_EVENTLOGRECORD_set_Length2(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->Length2");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->Length2));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->Length2 = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyGetSetDef py_EVENTLOGRECORD_getsetters[] = {
	{
		.name = discard_const_p(char, "Length"),
		.get = py_EVENTLOGRECORD_get_Length,
		.set = py_EVENTLOGRECORD_set_Length,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "Reserved"),
		.get = py_EVENTLOGRECORD_get_Reserved,
		.set = py_EVENTLOGRECORD_set_Reserved,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint8")
	},
	{
		.name = discard_const_p(char, "RecordNumber"),
		.get = py_EVENTLOGRECORD_get_RecordNumber,
		.set = py_EVENTLOGRECORD_set_RecordNumber,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "TimeGenerated"),
		.get = py_EVENTLOGRECORD_get_TimeGenerated,
		.set = py_EVENTLOGRECORD_set_TimeGenerated,
		.doc = discard_const_p(char, "PIDL-generated element of base type time_t")
	},
	{
		.name = discard_const_p(char, "TimeWritten"),
		.get = py_EVENTLOGRECORD_get_TimeWritten,
		.set = py_EVENTLOGRECORD_set_TimeWritten,
		.doc = discard_const_p(char, "PIDL-generated element of base type time_t")
	},
	{
		.name = discard_const_p(char, "EventID"),
		.get = py_EVENTLOGRECORD_get_EventID,
		.set = py_EVENTLOGRECORD_set_EventID,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "EventType"),
		.get = py_EVENTLOGRECORD_get_EventType,
		.set = py_EVENTLOGRECORD_set_EventType,
		.doc = discard_const_p(char, "PIDL-generated element of base type eventlogEventTypes")
	},
	{
		.name = discard_const_p(char, "NumStrings"),
		.get = py_EVENTLOGRECORD_get_NumStrings,
		.set = py_EVENTLOGRECORD_set_NumStrings,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint16")
	},
	{
		.name = discard_const_p(char, "EventCategory"),
		.get = py_EVENTLOGRECORD_get_EventCategory,
		.set = py_EVENTLOGRECORD_set_EventCategory,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint16")
	},
	{
		.name = discard_const_p(char, "ReservedFlags"),
		.get = py_EVENTLOGRECORD_get_ReservedFlags,
		.set = py_EVENTLOGRECORD_set_ReservedFlags,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint16")
	},
	{
		.name = discard_const_p(char, "ClosingRecordNumber"),
		.get = py_EVENTLOGRECORD_get_ClosingRecordNumber,
		.set = py_EVENTLOGRECORD_set_ClosingRecordNumber,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "StringOffset"),
		.get = py_EVENTLOGRECORD_get_StringOffset,
		.set = py_EVENTLOGRECORD_set_StringOffset,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "UserSidLength"),
		.get = py_EVENTLOGRECORD_get_UserSidLength,
		.set = py_EVENTLOGRECORD_set_UserSidLength,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "UserSidOffset"),
		.get = py_EVENTLOGRECORD_get_UserSidOffset,
		.set = py_EVENTLOGRECORD_set_UserSidOffset,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "DataLength"),
		.get = py_EVENTLOGRECORD_get_DataLength,
		.set = py_EVENTLOGRECORD_set_DataLength,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "DataOffset"),
		.get = py_EVENTLOGRECORD_get_DataOffset,
		.set = py_EVENTLOGRECORD_set_DataOffset,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "SourceName"),
		.get = py_EVENTLOGRECORD_get_SourceName,
		.set = py_EVENTLOGRECORD_set_SourceName,
		.doc = discard_const_p(char, "PIDL-generated element of base type string")
	},
	{
		.name = discard_const_p(char, "Computername"),
		.get = py_EVENTLOGRECORD_get_Computername,
		.set = py_EVENTLOGRECORD_set_Computername,
		.doc = discard_const_p(char, "PIDL-generated element of base type string")
	},
	{
		.name = discard_const_p(char, "UserSid"),
		.get = py_EVENTLOGRECORD_get_UserSid,
		.set = py_EVENTLOGRECORD_set_UserSid,
		.doc = discard_const_p(char, "PIDL-generated element of base type dom_sid0")
	},
	{
		.name = discard_const_p(char, "Strings"),
		.get = py_EVENTLOGRECORD_get_Strings,
		.set = py_EVENTLOGRECORD_set_Strings,
		.doc = discard_const_p(char, "PIDL-generated element of base type string")
	},
	{
		.name = discard_const_p(char, "Data"),
		.get = py_EVENTLOGRECORD_get_Data,
		.set = py_EVENTLOGRECORD_set_Data,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint8")
	},
	{
		.name = discard_const_p(char, "Pad"),
		.get = py_EVENTLOGRECORD_get_Pad,
		.set = py_EVENTLOGRECORD_set_Pad,
		.doc = discard_const_p(char, "PIDL-generated element of base type string")
	},
	{
		.name = discard_const_p(char, "Length2"),
		.get = py_EVENTLOGRECORD_get_Length2,
		.set = py_EVENTLOGRECORD_set_Length2,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{ .name = NULL }
};

static PyObject *py_EVENTLOGRECORD_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct EVENTLOGRECORD, type);
}

static PyObject *py_EVENTLOGRECORD_ndr_pack(PyObject *py_obj,  PyObject *Py_UNUSED(ignored))
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(py_obj);
	PyObject *ret = NULL;
	DATA_BLOB blob;
	enum ndr_err_code err;
	TALLOC_CTX *tmp_ctx = talloc_new(pytalloc_get_mem_ctx(py_obj));
	if (tmp_ctx == NULL) {
		PyErr_SetNdrError(NDR_ERR_ALLOC);
		return NULL;
	}
	err = ndr_push_struct_blob(&blob, tmp_ctx, object, (ndr_push_flags_fn_t)ndr_push_EVENTLOGRECORD);
	if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
		TALLOC_FREE(tmp_ctx);
		PyErr_SetNdrError(err);
		return NULL;
	}

	ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
	TALLOC_FREE(tmp_ctx);
	return ret;
}

static PyObject *py_EVENTLOGRECORD_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(py_obj);
	DATA_BLOB blob = {.data = NULL, .length = 0};
	Py_ssize_t blob_length = 0;
	enum ndr_err_code err;
	const char * const kwnames[] = { "data_blob", "allow_remaining", NULL };
	PyObject *allow_remaining_obj = NULL;
	bool allow_remaining = false;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|O:__ndr_unpack__",
		discard_const_p(char *, kwnames),
		&blob.data, &blob_length,
		&allow_remaining_obj)) {
		return NULL;
	}
	blob.length = blob_length;

	if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
		allow_remaining = true;
	}

	if (allow_remaining) {
		err = ndr_pull_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_EVENTLOGRECORD);
	} else {
		err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_EVENTLOGRECORD);
	}
	if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
		PyErr_SetNdrError(err);
		return NULL;
	}

	Py_RETURN_NONE;
}

static PyObject *py_EVENTLOGRECORD_ndr_print(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
{
	struct EVENTLOGRECORD *object = (struct EVENTLOGRECORD *)pytalloc_get_ptr(py_obj);
	PyObject *ret;
	char *retstr;

	retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_EVENTLOGRECORD, "EVENTLOGRECORD", object);
	ret = PyUnicode_FromString(retstr);
	talloc_free(retstr);

	return ret;
}

static PyMethodDef py_EVENTLOGRECORD_methods[] = {
	{ "__ndr_pack__", (PyCFunction)py_EVENTLOGRECORD_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
	{ "__ndr_unpack__", PY_DISCARD_FUNC_SIG(PyCFunction,py_EVENTLOGRECORD_ndr_unpack), METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack(class, blob, allow_remaining=False) -> None\nNDR unpack" },
	{ "__ndr_print__", (PyCFunction)py_EVENTLOGRECORD_ndr_print, METH_NOARGS, "S.ndr_print(object) -> None\nNDR print" },
	{ NULL, NULL, 0, NULL }
};


static PyTypeObject EVENTLOGRECORD_Type = {
	PyVarObject_HEAD_INIT(NULL, 0)
	.tp_name = "eventlog.EVENTLOGRECORD",
	.tp_getset = py_EVENTLOGRECORD_getsetters,
	.tp_methods = py_EVENTLOGRECORD_methods,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_new = py_EVENTLOGRECORD_new,
};


static PyObject *py_EVENTLOGEOF_get_RecordSizeBeginning(PyObject *obj, void *closure)
{
	struct EVENTLOGEOF *object = (struct EVENTLOGEOF *)pytalloc_get_ptr(obj);
	PyObject *py_RecordSizeBeginning;
	py_RecordSizeBeginning = PyLong_FromUnsignedLongLong((uint32_t)object->RecordSizeBeginning);
	return py_RecordSizeBeginning;
}

static int py_EVENTLOGEOF_set_RecordSizeBeginning(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOGEOF *object = (struct EVENTLOGEOF *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->RecordSizeBeginning");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->RecordSizeBeginning));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->RecordSizeBeginning = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_EVENTLOGEOF_get_One(PyObject *obj, void *closure)
{
	struct EVENTLOGEOF *object = (struct EVENTLOGEOF *)pytalloc_get_ptr(obj);
	PyObject *py_One;
	py_One = PyLong_FromUnsignedLongLong((uint32_t)object->One);
	return py_One;
}

static int py_EVENTLOGEOF_set_One(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOGEOF *object = (struct EVENTLOGEOF *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->One");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->One));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->One = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_EVENTLOGEOF_get_Two(PyObject *obj, void *closure)
{
	struct EVENTLOGEOF *object = (struct EVENTLOGEOF *)pytalloc_get_ptr(obj);
	PyObject *py_Two;
	py_Two = PyLong_FromUnsignedLongLong((uint32_t)object->Two);
	return py_Two;
}

static int py_EVENTLOGEOF_set_Two(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOGEOF *object = (struct EVENTLOGEOF *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->Two");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->Two));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->Two = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_EVENTLOGEOF_get_Three(PyObject *obj, void *closure)
{
	struct EVENTLOGEOF *object = (struct EVENTLOGEOF *)pytalloc_get_ptr(obj);
	PyObject *py_Three;
	py_Three = PyLong_FromUnsignedLongLong((uint32_t)object->Three);
	return py_Three;
}

static int py_EVENTLOGEOF_set_Three(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOGEOF *object = (struct EVENTLOGEOF *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->Three");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->Three));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->Three = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_EVENTLOGEOF_get_Four(PyObject *obj, void *closure)
{
	struct EVENTLOGEOF *object = (struct EVENTLOGEOF *)pytalloc_get_ptr(obj);
	PyObject *py_Four;
	py_Four = PyLong_FromUnsignedLongLong((uint32_t)object->Four);
	return py_Four;
}

static int py_EVENTLOGEOF_set_Four(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOGEOF *object = (struct EVENTLOGEOF *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->Four");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->Four));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->Four = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_EVENTLOGEOF_get_BeginRecord(PyObject *obj, void *closure)
{
	struct EVENTLOGEOF *object = (struct EVENTLOGEOF *)pytalloc_get_ptr(obj);
	PyObject *py_BeginRecord;
	py_BeginRecord = PyLong_FromUnsignedLongLong((uint32_t)object->BeginRecord);
	return py_BeginRecord;
}

static int py_EVENTLOGEOF_set_BeginRecord(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOGEOF *object = (struct EVENTLOGEOF *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->BeginRecord");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->BeginRecord));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->BeginRecord = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_EVENTLOGEOF_get_EndRecord(PyObject *obj, void *closure)
{
	struct EVENTLOGEOF *object = (struct EVENTLOGEOF *)pytalloc_get_ptr(obj);
	PyObject *py_EndRecord;
	py_EndRecord = PyLong_FromUnsignedLongLong((uint32_t)object->EndRecord);
	return py_EndRecord;
}

static int py_EVENTLOGEOF_set_EndRecord(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOGEOF *object = (struct EVENTLOGEOF *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->EndRecord");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->EndRecord));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->EndRecord = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_EVENTLOGEOF_get_CurrentRecordNumber(PyObject *obj, void *closure)
{
	struct EVENTLOGEOF *object = (struct EVENTLOGEOF *)pytalloc_get_ptr(obj);
	PyObject *py_CurrentRecordNumber;
	py_CurrentRecordNumber = PyLong_FromUnsignedLongLong((uint32_t)object->CurrentRecordNumber);
	return py_CurrentRecordNumber;
}

static int py_EVENTLOGEOF_set_CurrentRecordNumber(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOGEOF *object = (struct EVENTLOGEOF *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->CurrentRecordNumber");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->CurrentRecordNumber));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->CurrentRecordNumber = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_EVENTLOGEOF_get_OldestRecordNumber(PyObject *obj, void *closure)
{
	struct EVENTLOGEOF *object = (struct EVENTLOGEOF *)pytalloc_get_ptr(obj);
	PyObject *py_OldestRecordNumber;
	py_OldestRecordNumber = PyLong_FromUnsignedLongLong((uint32_t)object->OldestRecordNumber);
	return py_OldestRecordNumber;
}

static int py_EVENTLOGEOF_set_OldestRecordNumber(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOGEOF *object = (struct EVENTLOGEOF *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->OldestRecordNumber");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->OldestRecordNumber));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->OldestRecordNumber = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_EVENTLOGEOF_get_RecordSizeEnd(PyObject *obj, void *closure)
{
	struct EVENTLOGEOF *object = (struct EVENTLOGEOF *)pytalloc_get_ptr(obj);
	PyObject *py_RecordSizeEnd;
	py_RecordSizeEnd = PyLong_FromUnsignedLongLong((uint32_t)object->RecordSizeEnd);
	return py_RecordSizeEnd;
}

static int py_EVENTLOGEOF_set_RecordSizeEnd(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOGEOF *object = (struct EVENTLOGEOF *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->RecordSizeEnd");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->RecordSizeEnd));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->RecordSizeEnd = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyGetSetDef py_EVENTLOGEOF_getsetters[] = {
	{
		.name = discard_const_p(char, "RecordSizeBeginning"),
		.get = py_EVENTLOGEOF_get_RecordSizeBeginning,
		.set = py_EVENTLOGEOF_set_RecordSizeBeginning,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "One"),
		.get = py_EVENTLOGEOF_get_One,
		.set = py_EVENTLOGEOF_set_One,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "Two"),
		.get = py_EVENTLOGEOF_get_Two,
		.set = py_EVENTLOGEOF_set_Two,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "Three"),
		.get = py_EVENTLOGEOF_get_Three,
		.set = py_EVENTLOGEOF_set_Three,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "Four"),
		.get = py_EVENTLOGEOF_get_Four,
		.set = py_EVENTLOGEOF_set_Four,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "BeginRecord"),
		.get = py_EVENTLOGEOF_get_BeginRecord,
		.set = py_EVENTLOGEOF_set_BeginRecord,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "EndRecord"),
		.get = py_EVENTLOGEOF_get_EndRecord,
		.set = py_EVENTLOGEOF_set_EndRecord,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "CurrentRecordNumber"),
		.get = py_EVENTLOGEOF_get_CurrentRecordNumber,
		.set = py_EVENTLOGEOF_set_CurrentRecordNumber,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "OldestRecordNumber"),
		.get = py_EVENTLOGEOF_get_OldestRecordNumber,
		.set = py_EVENTLOGEOF_set_OldestRecordNumber,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "RecordSizeEnd"),
		.get = py_EVENTLOGEOF_get_RecordSizeEnd,
		.set = py_EVENTLOGEOF_set_RecordSizeEnd,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{ .name = NULL }
};

static PyObject *py_EVENTLOGEOF_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct EVENTLOGEOF, type);
}

static PyObject *py_EVENTLOGEOF_ndr_pack(PyObject *py_obj,  PyObject *Py_UNUSED(ignored))
{
	struct EVENTLOGEOF *object = (struct EVENTLOGEOF *)pytalloc_get_ptr(py_obj);
	PyObject *ret = NULL;
	DATA_BLOB blob;
	enum ndr_err_code err;
	TALLOC_CTX *tmp_ctx = talloc_new(pytalloc_get_mem_ctx(py_obj));
	if (tmp_ctx == NULL) {
		PyErr_SetNdrError(NDR_ERR_ALLOC);
		return NULL;
	}
	err = ndr_push_struct_blob(&blob, tmp_ctx, object, (ndr_push_flags_fn_t)ndr_push_EVENTLOGEOF);
	if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
		TALLOC_FREE(tmp_ctx);
		PyErr_SetNdrError(err);
		return NULL;
	}

	ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
	TALLOC_FREE(tmp_ctx);
	return ret;
}

static PyObject *py_EVENTLOGEOF_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	struct EVENTLOGEOF *object = (struct EVENTLOGEOF *)pytalloc_get_ptr(py_obj);
	DATA_BLOB blob = {.data = NULL, .length = 0};
	Py_ssize_t blob_length = 0;
	enum ndr_err_code err;
	const char * const kwnames[] = { "data_blob", "allow_remaining", NULL };
	PyObject *allow_remaining_obj = NULL;
	bool allow_remaining = false;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|O:__ndr_unpack__",
		discard_const_p(char *, kwnames),
		&blob.data, &blob_length,
		&allow_remaining_obj)) {
		return NULL;
	}
	blob.length = blob_length;

	if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
		allow_remaining = true;
	}

	if (allow_remaining) {
		err = ndr_pull_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_EVENTLOGEOF);
	} else {
		err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_EVENTLOGEOF);
	}
	if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
		PyErr_SetNdrError(err);
		return NULL;
	}

	Py_RETURN_NONE;
}

static PyObject *py_EVENTLOGEOF_ndr_print(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
{
	struct EVENTLOGEOF *object = (struct EVENTLOGEOF *)pytalloc_get_ptr(py_obj);
	PyObject *ret;
	char *retstr;

	retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_EVENTLOGEOF, "EVENTLOGEOF", object);
	ret = PyUnicode_FromString(retstr);
	talloc_free(retstr);

	return ret;
}

static PyMethodDef py_EVENTLOGEOF_methods[] = {
	{ "__ndr_pack__", (PyCFunction)py_EVENTLOGEOF_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
	{ "__ndr_unpack__", PY_DISCARD_FUNC_SIG(PyCFunction,py_EVENTLOGEOF_ndr_unpack), METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack(class, blob, allow_remaining=False) -> None\nNDR unpack" },
	{ "__ndr_print__", (PyCFunction)py_EVENTLOGEOF_ndr_print, METH_NOARGS, "S.ndr_print(object) -> None\nNDR print" },
	{ NULL, NULL, 0, NULL }
};


static PyTypeObject EVENTLOGEOF_Type = {
	PyVarObject_HEAD_INIT(NULL, 0)
	.tp_name = "eventlog.EVENTLOGEOF",
	.tp_getset = py_EVENTLOGEOF_getsetters,
	.tp_methods = py_EVENTLOGEOF_methods,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_new = py_EVENTLOGEOF_new,
};


static PyObject *py_EVENTLOG_EVT_FILE_get_hdr(PyObject *obj, void *closure)
{
	struct EVENTLOG_EVT_FILE *object = (struct EVENTLOG_EVT_FILE *)pytalloc_get_ptr(obj);
	PyObject *py_hdr;
	py_hdr = pytalloc_reference_ex(&EVENTLOGHEADER_Type, pytalloc_get_mem_ctx(obj), &object->hdr);
	return py_hdr;
}

static int py_EVENTLOG_EVT_FILE_set_hdr(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOG_EVT_FILE *object = (struct EVENTLOG_EVT_FILE *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->hdr");
		return -1;
	}
	PY_CHECK_TYPE(&EVENTLOGHEADER_Type, value, return -1;);
	if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	object->hdr = *(struct EVENTLOGHEADER *)pytalloc_get_ptr(value);
	return 0;
}

static PyObject *py_EVENTLOG_EVT_FILE_get_records(PyObject *obj, void *closure)
{
	struct EVENTLOG_EVT_FILE *object = (struct EVENTLOG_EVT_FILE *)pytalloc_get_ptr(obj);
	PyObject *py_records;
	py_records = PyList_New(object->hdr.CurrentRecordNumber - object->hdr.OldestRecordNumber);
	if (py_records == NULL) {
		return NULL;
	}
	{
		int records_cntr_0;
		for (records_cntr_0 = 0; records_cntr_0 < (object->hdr.CurrentRecordNumber - object->hdr.OldestRecordNumber); records_cntr_0++) {
			PyObject *py_records_0;
			py_records_0 = pytalloc_reference_ex(&EVENTLOGRECORD_Type, object->records, &object->records[records_cntr_0]);
			PyList_SetItem(py_records, records_cntr_0, py_records_0);
		}
	}
	return py_records;
}

static int py_EVENTLOG_EVT_FILE_set_records(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOG_EVT_FILE *object = (struct EVENTLOG_EVT_FILE *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->records");
		return -1;
	}
	PY_CHECK_TYPE(&PyList_Type, value, return -1;);
	{
		int records_cntr_0;
		object->records = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->records, PyList_GET_SIZE(value));
		if (!object->records) { return -1;; }
		talloc_set_name_const(object->records, "ARRAY: object->records");
		for (records_cntr_0 = 0; records_cntr_0 < PyList_GET_SIZE(value); records_cntr_0++) {
			if (PyList_GET_ITEM(value, records_cntr_0) == NULL) {
				PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->records[records_cntr_0]");
				return -1;
			}
			PY_CHECK_TYPE(&EVENTLOGRECORD_Type, PyList_GET_ITEM(value, records_cntr_0), return -1;);
			if (talloc_reference(object->records, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, records_cntr_0))) == NULL) {
				PyErr_NoMemory();
				return -1;
			}
			object->records[records_cntr_0] = *(struct EVENTLOGRECORD *)pytalloc_get_ptr(PyList_GET_ITEM(value, records_cntr_0));
		}
	}
	return 0;
}

static PyObject *py_EVENTLOG_EVT_FILE_get_eof(PyObject *obj, void *closure)
{
	struct EVENTLOG_EVT_FILE *object = (struct EVENTLOG_EVT_FILE *)pytalloc_get_ptr(obj);
	PyObject *py_eof;
	py_eof = pytalloc_reference_ex(&EVENTLOGEOF_Type, pytalloc_get_mem_ctx(obj), &object->eof);
	return py_eof;
}

static int py_EVENTLOG_EVT_FILE_set_eof(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOG_EVT_FILE *object = (struct EVENTLOG_EVT_FILE *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->eof");
		return -1;
	}
	PY_CHECK_TYPE(&EVENTLOGEOF_Type, value, return -1;);
	if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	object->eof = *(struct EVENTLOGEOF *)pytalloc_get_ptr(value);
	return 0;
}

static PyGetSetDef py_EVENTLOG_EVT_FILE_getsetters[] = {
	{
		.name = discard_const_p(char, "hdr"),
		.get = py_EVENTLOG_EVT_FILE_get_hdr,
		.set = py_EVENTLOG_EVT_FILE_set_hdr,
		.doc = discard_const_p(char, "PIDL-generated element of base type EVENTLOGHEADER")
	},
	{
		.name = discard_const_p(char, "records"),
		.get = py_EVENTLOG_EVT_FILE_get_records,
		.set = py_EVENTLOG_EVT_FILE_set_records,
		.doc = discard_const_p(char, "PIDL-generated element of base type EVENTLOGRECORD")
	},
	{
		.name = discard_const_p(char, "eof"),
		.get = py_EVENTLOG_EVT_FILE_get_eof,
		.set = py_EVENTLOG_EVT_FILE_set_eof,
		.doc = discard_const_p(char, "PIDL-generated element of base type EVENTLOGEOF")
	},
	{ .name = NULL }
};

static PyObject *py_EVENTLOG_EVT_FILE_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct EVENTLOG_EVT_FILE, type);
}

static PyObject *py_EVENTLOG_EVT_FILE_ndr_pack(PyObject *py_obj,  PyObject *Py_UNUSED(ignored))
{
	struct EVENTLOG_EVT_FILE *object = (struct EVENTLOG_EVT_FILE *)pytalloc_get_ptr(py_obj);
	PyObject *ret = NULL;
	DATA_BLOB blob;
	enum ndr_err_code err;
	TALLOC_CTX *tmp_ctx = talloc_new(pytalloc_get_mem_ctx(py_obj));
	if (tmp_ctx == NULL) {
		PyErr_SetNdrError(NDR_ERR_ALLOC);
		return NULL;
	}
	err = ndr_push_struct_blob(&blob, tmp_ctx, object, (ndr_push_flags_fn_t)ndr_push_EVENTLOG_EVT_FILE);
	if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
		TALLOC_FREE(tmp_ctx);
		PyErr_SetNdrError(err);
		return NULL;
	}

	ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
	TALLOC_FREE(tmp_ctx);
	return ret;
}

static PyObject *py_EVENTLOG_EVT_FILE_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	struct EVENTLOG_EVT_FILE *object = (struct EVENTLOG_EVT_FILE *)pytalloc_get_ptr(py_obj);
	DATA_BLOB blob = {.data = NULL, .length = 0};
	Py_ssize_t blob_length = 0;
	enum ndr_err_code err;
	const char * const kwnames[] = { "data_blob", "allow_remaining", NULL };
	PyObject *allow_remaining_obj = NULL;
	bool allow_remaining = false;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|O:__ndr_unpack__",
		discard_const_p(char *, kwnames),
		&blob.data, &blob_length,
		&allow_remaining_obj)) {
		return NULL;
	}
	blob.length = blob_length;

	if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
		allow_remaining = true;
	}

	if (allow_remaining) {
		err = ndr_pull_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_EVENTLOG_EVT_FILE);
	} else {
		err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_EVENTLOG_EVT_FILE);
	}
	if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
		PyErr_SetNdrError(err);
		return NULL;
	}

	Py_RETURN_NONE;
}

static PyObject *py_EVENTLOG_EVT_FILE_ndr_print(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
{
	struct EVENTLOG_EVT_FILE *object = (struct EVENTLOG_EVT_FILE *)pytalloc_get_ptr(py_obj);
	PyObject *ret;
	char *retstr;

	retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_EVENTLOG_EVT_FILE, "EVENTLOG_EVT_FILE", object);
	ret = PyUnicode_FromString(retstr);
	talloc_free(retstr);

	return ret;
}

static PyMethodDef py_EVENTLOG_EVT_FILE_methods[] = {
	{ "__ndr_pack__", (PyCFunction)py_EVENTLOG_EVT_FILE_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
	{ "__ndr_unpack__", PY_DISCARD_FUNC_SIG(PyCFunction,py_EVENTLOG_EVT_FILE_ndr_unpack), METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack(class, blob, allow_remaining=False) -> None\nNDR unpack" },
	{ "__ndr_print__", (PyCFunction)py_EVENTLOG_EVT_FILE_ndr_print, METH_NOARGS, "S.ndr_print(object) -> None\nNDR print" },
	{ NULL, NULL, 0, NULL }
};


static PyTypeObject EVENTLOG_EVT_FILE_Type = {
	PyVarObject_HEAD_INIT(NULL, 0)
	.tp_name = "eventlog.EVENTLOG_EVT_FILE",
	.tp_getset = py_EVENTLOG_EVT_FILE_getsetters,
	.tp_methods = py_EVENTLOG_EVT_FILE_methods,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_new = py_EVENTLOG_EVT_FILE_new,
};


static PyObject *py_EVENTLOG_FULL_INFORMATION_get_full(PyObject *obj, void *closure)
{
	struct EVENTLOG_FULL_INFORMATION *object = (struct EVENTLOG_FULL_INFORMATION *)pytalloc_get_ptr(obj);
	PyObject *py_full;
	py_full = PyLong_FromUnsignedLongLong((uint32_t)object->full);
	return py_full;
}

static int py_EVENTLOG_FULL_INFORMATION_set_full(PyObject *py_obj, PyObject *value, void *closure)
{
	struct EVENTLOG_FULL_INFORMATION *object = (struct EVENTLOG_FULL_INFORMATION *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->full");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->full));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->full = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyGetSetDef py_EVENTLOG_FULL_INFORMATION_getsetters[] = {
	{
		.name = discard_const_p(char, "full"),
		.get = py_EVENTLOG_FULL_INFORMATION_get_full,
		.set = py_EVENTLOG_FULL_INFORMATION_set_full,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{ .name = NULL }
};

static PyObject *py_EVENTLOG_FULL_INFORMATION_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return pytalloc_new(struct EVENTLOG_FULL_INFORMATION, type);
}

static PyObject *py_EVENTLOG_FULL_INFORMATION_ndr_pack(PyObject *py_obj,  PyObject *Py_UNUSED(ignored))
{
	struct EVENTLOG_FULL_INFORMATION *object = (struct EVENTLOG_FULL_INFORMATION *)pytalloc_get_ptr(py_obj);
	PyObject *ret = NULL;
	DATA_BLOB blob;
	enum ndr_err_code err;
	TALLOC_CTX *tmp_ctx = talloc_new(pytalloc_get_mem_ctx(py_obj));
	if (tmp_ctx == NULL) {
		PyErr_SetNdrError(NDR_ERR_ALLOC);
		return NULL;
	}
	err = ndr_push_struct_blob(&blob, tmp_ctx, object, (ndr_push_flags_fn_t)ndr_push_EVENTLOG_FULL_INFORMATION);
	if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
		TALLOC_FREE(tmp_ctx);
		PyErr_SetNdrError(err);
		return NULL;
	}

	ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
	TALLOC_FREE(tmp_ctx);
	return ret;
}

static PyObject *py_EVENTLOG_FULL_INFORMATION_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	struct EVENTLOG_FULL_INFORMATION *object = (struct EVENTLOG_FULL_INFORMATION *)pytalloc_get_ptr(py_obj);
	DATA_BLOB blob = {.data = NULL, .length = 0};
	Py_ssize_t blob_length = 0;
	enum ndr_err_code err;
	const char * const kwnames[] = { "data_blob", "allow_remaining", NULL };
	PyObject *allow_remaining_obj = NULL;
	bool allow_remaining = false;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|O:__ndr_unpack__",
		discard_const_p(char *, kwnames),
		&blob.data, &blob_length,
		&allow_remaining_obj)) {
		return NULL;
	}
	blob.length = blob_length;

	if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
		allow_remaining = true;
	}

	if (allow_remaining) {
		err = ndr_pull_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_EVENTLOG_FULL_INFORMATION);
	} else {
		err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_EVENTLOG_FULL_INFORMATION);
	}
	if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
		PyErr_SetNdrError(err);
		return NULL;
	}

	Py_RETURN_NONE;
}

static PyObject *py_EVENTLOG_FULL_INFORMATION_ndr_print(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
{
	struct EVENTLOG_FULL_INFORMATION *object = (struct EVENTLOG_FULL_INFORMATION *)pytalloc_get_ptr(py_obj);
	PyObject *ret;
	char *retstr;

	retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_EVENTLOG_FULL_INFORMATION, "EVENTLOG_FULL_INFORMATION", object);
	ret = PyUnicode_FromString(retstr);
	talloc_free(retstr);

	return ret;
}

static PyMethodDef py_EVENTLOG_FULL_INFORMATION_methods[] = {
	{ "__ndr_pack__", (PyCFunction)py_EVENTLOG_FULL_INFORMATION_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
	{ "__ndr_unpack__", PY_DISCARD_FUNC_SIG(PyCFunction,py_EVENTLOG_FULL_INFORMATION_ndr_unpack), METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack(class, blob, allow_remaining=False) -> None\nNDR unpack" },
	{ "__ndr_print__", (PyCFunction)py_EVENTLOG_FULL_INFORMATION_ndr_print, METH_NOARGS, "S.ndr_print(object) -> None\nNDR print" },
	{ NULL, NULL, 0, NULL }
};


static PyTypeObject EVENTLOG_FULL_INFORMATION_Type = {
	PyVarObject_HEAD_INIT(NULL, 0)
	.tp_name = "eventlog.EVENTLOG_FULL_INFORMATION",
	.tp_getset = py_EVENTLOG_FULL_INFORMATION_getsetters,
	.tp_methods = py_EVENTLOG_FULL_INFORMATION_methods,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_new = py_EVENTLOG_FULL_INFORMATION_new,
};



static PyObject *py_eventlog_ClearEventLogW_in_get_handle(PyObject *obj, void *closure)
{
	struct eventlog_ClearEventLogW *object = (struct eventlog_ClearEventLogW *)pytalloc_get_ptr(obj);
	PyObject *py_handle;
	if (object->in.handle == NULL) {
		Py_RETURN_NONE;
	}
	py_handle = pytalloc_reference_ex(policy_handle_Type, object->in.handle, object->in.handle);
	return py_handle;
}

static int py_eventlog_ClearEventLogW_in_set_handle(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_ClearEventLogW *object = (struct eventlog_ClearEventLogW *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.handle));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.handle");
		return -1;
	}
	object->in.handle = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->in.handle);
	if (object->in.handle == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	PY_CHECK_TYPE(policy_handle_Type, value, return -1;);
	if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	object->in.handle = (struct policy_handle *)pytalloc_get_ptr(value);
	return 0;
}

static PyObject *py_eventlog_ClearEventLogW_in_get_backupfile(PyObject *obj, void *closure)
{
	struct eventlog_ClearEventLogW *object = (struct eventlog_ClearEventLogW *)pytalloc_get_ptr(obj);
	PyObject *py_backupfile;
	if (object->in.backupfile == NULL) {
		Py_RETURN_NONE;
	}
	if (object->in.backupfile == NULL) {
		py_backupfile = Py_None;
		Py_INCREF(py_backupfile);
	} else {
		py_backupfile = pytalloc_reference_ex(lsa_String_Type, object->in.backupfile, object->in.backupfile);
	}
	return py_backupfile;
}

static int py_eventlog_ClearEventLogW_in_set_backupfile(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_ClearEventLogW *object = (struct eventlog_ClearEventLogW *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.backupfile));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.backupfile");
		return -1;
	}
	if (value == Py_None) {
		object->in.backupfile = NULL;
	} else {
		object->in.backupfile = NULL;
		PY_CHECK_TYPE(lsa_String_Type, value, return -1;);
		if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
			PyErr_NoMemory();
			return -1;
		}
		object->in.backupfile = (struct lsa_String *)pytalloc_get_ptr(value);
	}
	return 0;
}

static PyObject *py_eventlog_ClearEventLogW_get_result(PyObject *obj, void *closure)
{
	struct eventlog_ClearEventLogW *object = (struct eventlog_ClearEventLogW *)pytalloc_get_ptr(obj);
	PyObject *py_result;
	py_result = PyErr_FromNTSTATUS(object->out.result);
	return py_result;
}

static int py_eventlog_ClearEventLogW_set_result(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_ClearEventLogW *object = (struct eventlog_ClearEventLogW *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->out.result");
		return -1;
	}
	object->out.result = NT_STATUS(PyLong_AsLong(value));
	return 0;
}

static PyGetSetDef py_eventlog_ClearEventLogW_getsetters[] = {
	{
		.name = discard_const_p(char, "in_handle"),
		.get = py_eventlog_ClearEventLogW_in_get_handle,
		.set = py_eventlog_ClearEventLogW_in_set_handle,
		.doc = discard_const_p(char, "PIDL-generated element of base type policy_handle")
	},
	{
		.name = discard_const_p(char, "in_backupfile"),
		.get = py_eventlog_ClearEventLogW_in_get_backupfile,
		.set = py_eventlog_ClearEventLogW_in_set_backupfile,
		.doc = discard_const_p(char, "PIDL-generated element of base type lsa_String")
	},
	{
		.name = discard_const_p(char, "result"),
		.get = py_eventlog_ClearEventLogW_get_result,
		.set = py_eventlog_ClearEventLogW_set_result,
		.doc = discard_const_p(char, "PIDL-generated element of type NTSTATUS")
	},
	{ .name = NULL }
};

static PyObject *py_eventlog_ClearEventLogW_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	PyObject *self = pytalloc_new(struct eventlog_ClearEventLogW, type);
	struct eventlog_ClearEventLogW *_self = (struct eventlog_ClearEventLogW *)pytalloc_get_ptr(self);
	TALLOC_CTX *mem_ctx = pytalloc_get_mem_ctx(self);
	_self->in.handle = talloc_zero(mem_ctx, struct policy_handle);
	return self;
}

static PyObject *py_eventlog_ClearEventLogW_ndr_opnum(PyTypeObject *type, PyObject *Py_UNUSED(ignored))
{


	return PyLong_FromLong(0);
}

static PyObject *py_eventlog_ClearEventLogW_ndr_pack(PyObject *py_obj, int ndr_inout_flags, uint32_t ndr_push_flags)
{
	const struct ndr_interface_call *call = NULL;
	struct eventlog_ClearEventLogW *object = (struct eventlog_ClearEventLogW *)pytalloc_get_ptr(py_obj);
	PyObject *ret = NULL;
	struct ndr_push *push = NULL;
	DATA_BLOB blob;
	enum ndr_err_code err;

	if (ndr_table_eventlog.num_calls < 1) {
		PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_eventlog_ClearEventLogW_ndr_pack");
		return NULL;
	}
	call = &ndr_table_eventlog.calls[0];

	push = ndr_push_init_ctx(pytalloc_get_mem_ctx(py_obj));
	if (push == NULL) {
		PyErr_SetNdrError(NDR_ERR_ALLOC);
		return NULL;
	}

	push->flags |= ndr_push_flags;

	err = call->ndr_push(push, ndr_inout_flags, object);
	if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
		TALLOC_FREE(push);
		PyErr_SetNdrError(err);
		return NULL;
	}
	blob = ndr_push_blob(push);
	ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
	TALLOC_FREE(push);
	return ret;
}

static PyObject *py_eventlog_ClearEventLogW_ndr_pack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	const char * const kwnames[] = { "bigendian", "ndr64", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_push_flags = 0;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_in__",
		discard_const_p(char *, kwnames),
		&bigendian_obj,
		&ndr64_obj)) {
		return NULL;
	}

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_NDR64;
	}

	return py_eventlog_ClearEventLogW_ndr_pack(py_obj, NDR_IN, ndr_push_flags);
}

static PyObject *py_eventlog_ClearEventLogW_ndr_pack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	const char * const kwnames[] = { "bigendian", "ndr64", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_push_flags = 0;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_out__",
		discard_const_p(char *, kwnames),
		&bigendian_obj,
		&ndr64_obj)) {
		return NULL;
	}

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_NDR64;
	}

	return py_eventlog_ClearEventLogW_ndr_pack(py_obj, NDR_OUT, ndr_push_flags);
}

static PyObject *py_eventlog_ClearEventLogW_ndr_unpack(PyObject *py_obj, const DATA_BLOB *blob, int ndr_inout_flags, uint32_t ndr_pull_flags, bool allow_remaining)
{
	const struct ndr_interface_call *call = NULL;
	struct eventlog_ClearEventLogW *object = (struct eventlog_ClearEventLogW *)pytalloc_get_ptr(py_obj);
	struct ndr_pull *pull = NULL;
	enum ndr_err_code err;

	if (ndr_table_eventlog.num_calls < 1) {
		PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_eventlog_ClearEventLogW_ndr_unpack");
		return NULL;
	}
	call = &ndr_table_eventlog.calls[0];

	pull = ndr_pull_init_blob(blob, object);
	if (pull == NULL) {
		PyErr_SetNdrError(NDR_ERR_ALLOC);
		return NULL;
	}

	pull->flags |= ndr_pull_flags;

	err = call->ndr_pull(pull, ndr_inout_flags, object);
	if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
		TALLOC_FREE(pull);
		PyErr_SetNdrError(err);
		return NULL;
	}
	if (!allow_remaining) {
		uint32_t highest_ofs;

		if (pull->offset > pull->relative_highest_offset) {
			highest_ofs = pull->offset;
		} else {
			highest_ofs = pull->relative_highest_offset;
		}
		if (highest_ofs < pull->data_size) {
			err = ndr_pull_error(pull, NDR_ERR_UNREAD_BYTES,
				"not all bytes consumed ofs[%u] size[%u]",
				highest_ofs, pull->data_size);
			TALLOC_FREE(pull);
			PyErr_SetNdrError(err);
			return NULL;
		}
	}

	TALLOC_FREE(pull);
	Py_RETURN_NONE;
}

static PyObject *py_eventlog_ClearEventLogW_ndr_unpack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	DATA_BLOB blob;
	Py_ssize_t blob_length = 0;
	const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
	PyObject *allow_remaining_obj = NULL;
	bool allow_remaining = false;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_in__",
		discard_const_p(char *, kwnames),
		&blob.data, &blob_length,
		&bigendian_obj,
		&ndr64_obj,
		&allow_remaining_obj)) {
		return NULL;
	}
	blob.length = blob_length;

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_NDR64;
	}

	if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
		allow_remaining = true;
	}

	return py_eventlog_ClearEventLogW_ndr_unpack(py_obj, &blob, NDR_IN, ndr_pull_flags, allow_remaining);
}

static PyObject *py_eventlog_ClearEventLogW_ndr_unpack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	DATA_BLOB blob;
	Py_ssize_t blob_length = 0;
	const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
	PyObject *allow_remaining_obj = NULL;
	bool allow_remaining = false;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_out__",
		discard_const_p(char *, kwnames),
		&blob.data, &blob_length,
		&bigendian_obj,
		&ndr64_obj,
		&allow_remaining_obj)) {
		return NULL;
	}
	blob.length = blob_length;

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_NDR64;
	}

	if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
		allow_remaining = true;
	}

	return py_eventlog_ClearEventLogW_ndr_unpack(py_obj, &blob, NDR_OUT, ndr_pull_flags, allow_remaining);
}

static PyObject *py_eventlog_ClearEventLogW_ndr_print(PyObject *py_obj, const char *name, int ndr_inout_flags)
{
	const struct ndr_interface_call *call = NULL;
	struct eventlog_ClearEventLogW *object = (struct eventlog_ClearEventLogW *)pytalloc_get_ptr(py_obj);
	PyObject *ret;
	char *retstr;

	if (ndr_table_eventlog.num_calls < 1) {
		PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_eventlog_ClearEventLogW_ndr_print");
		return NULL;
	}
	call = &ndr_table_eventlog.calls[0];

	retstr = ndr_print_function_string(pytalloc_get_mem_ctx(py_obj), call->ndr_print, name, ndr_inout_flags, object);
	ret = PyUnicode_FromString(retstr);
	TALLOC_FREE(retstr);

	return ret;
}

static PyObject *py_eventlog_ClearEventLogW_ndr_print_in(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
{
	return py_eventlog_ClearEventLogW_ndr_print(py_obj, "eventlog_ClearEventLogW_in", NDR_IN);
}

static PyObject *py_eventlog_ClearEventLogW_ndr_print_out(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
{
	return py_eventlog_ClearEventLogW_ndr_print(py_obj, "eventlog_ClearEventLogW_out", NDR_OUT);
}

static PyMethodDef py_eventlog_ClearEventLogW_methods[] = {
	{ "opnum", (PyCFunction)py_eventlog_ClearEventLogW_ndr_opnum, METH_NOARGS|METH_CLASS,
		"eventlog.ClearEventLogW.opnum() -> 0 (0x00) " },
	{ "__ndr_pack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_ClearEventLogW_ndr_pack_in), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_pack_in(object, bigendian=False, ndr64=False) -> blob\nNDR pack input" },
	{ "__ndr_pack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_ClearEventLogW_ndr_pack_out), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_pack_out(object, bigendian=False, ndr64=False) -> blob\nNDR pack output" },
	{ "__ndr_unpack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_ClearEventLogW_ndr_unpack_in), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_unpack_in(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack input" },
	{ "__ndr_unpack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_ClearEventLogW_ndr_unpack_out), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_unpack_out(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack output" },
	{ "__ndr_print_in__", (PyCFunction)py_eventlog_ClearEventLogW_ndr_print_in, METH_NOARGS, "S.ndr_print_in(object) -> None\nNDR print input" },
	{ "__ndr_print_out__", (PyCFunction)py_eventlog_ClearEventLogW_ndr_print_out, METH_NOARGS, "S.ndr_print_out(object) -> None\nNDR print output" },
	{ NULL, NULL, 0, NULL }
};


static PyTypeObject eventlog_ClearEventLogW_Type = {
	PyVarObject_HEAD_INIT(NULL, 0)
	.tp_name = "eventlog.ClearEventLogW",
	.tp_getset = py_eventlog_ClearEventLogW_getsetters,
	.tp_methods = py_eventlog_ClearEventLogW_methods,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_new = py_eventlog_ClearEventLogW_new,
};

static bool pack_py_eventlog_ClearEventLogW_args_in(PyObject *args, PyObject *kwargs, struct eventlog_ClearEventLogW *r)
{
	PyObject *py_handle;
	PyObject *py_backupfile;
	const char *kwnames[] = {
		"handle", "backupfile", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:eventlog_ClearEventLogW", discard_const_p(char *, kwnames), &py_handle, &py_backupfile)) {
		return false;
	}

	if (py_handle == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.handle");
		return false;
	}
	r->in.handle = talloc_ptrtype(r, r->in.handle);
	if (r->in.handle == NULL) {
		PyErr_NoMemory();
		return false;
	}
	PY_CHECK_TYPE(policy_handle_Type, py_handle, return false;);
	if (talloc_reference(r, pytalloc_get_mem_ctx(py_handle)) == NULL) {
		PyErr_NoMemory();
		return false;
	}
	r->in.handle = (struct policy_handle *)pytalloc_get_ptr(py_handle);
	if (py_backupfile == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.backupfile");
		return false;
	}
	if (py_backupfile == Py_None) {
		r->in.backupfile = NULL;
	} else {
		r->in.backupfile = NULL;
		PY_CHECK_TYPE(lsa_String_Type, py_backupfile, return false;);
		if (talloc_reference(r, pytalloc_get_mem_ctx(py_backupfile)) == NULL) {
			PyErr_NoMemory();
			return false;
		}
		r->in.backupfile = (struct lsa_String *)pytalloc_get_ptr(py_backupfile);
	}
	return true;
}

static PyObject *unpack_py_eventlog_ClearEventLogW_args_out(struct eventlog_ClearEventLogW *r)
{
	PyObject *result;
	result = Py_None;
	Py_INCREF(result);
	if (NT_STATUS_IS_ERR(r->out.result)) {
		PyErr_SetNTSTATUS(r->out.result);
		return NULL;
	}

	return result;
}


static PyObject *py_eventlog_BackupEventLogW_in_get_handle(PyObject *obj, void *closure)
{
	struct eventlog_BackupEventLogW *object = (struct eventlog_BackupEventLogW *)pytalloc_get_ptr(obj);
	PyObject *py_handle;
	if (object->in.handle == NULL) {
		Py_RETURN_NONE;
	}
	py_handle = pytalloc_reference_ex(policy_handle_Type, object->in.handle, object->in.handle);
	return py_handle;
}

static int py_eventlog_BackupEventLogW_in_set_handle(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_BackupEventLogW *object = (struct eventlog_BackupEventLogW *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.handle));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.handle");
		return -1;
	}
	object->in.handle = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->in.handle);
	if (object->in.handle == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	PY_CHECK_TYPE(policy_handle_Type, value, return -1;);
	if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	object->in.handle = (struct policy_handle *)pytalloc_get_ptr(value);
	return 0;
}

static PyObject *py_eventlog_BackupEventLogW_in_get_backup_filename(PyObject *obj, void *closure)
{
	struct eventlog_BackupEventLogW *object = (struct eventlog_BackupEventLogW *)pytalloc_get_ptr(obj);
	PyObject *py_backup_filename;
	if (object->in.backup_filename == NULL) {
		Py_RETURN_NONE;
	}
	py_backup_filename = pytalloc_reference_ex(lsa_String_Type, object->in.backup_filename, object->in.backup_filename);
	return py_backup_filename;
}

static int py_eventlog_BackupEventLogW_in_set_backup_filename(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_BackupEventLogW *object = (struct eventlog_BackupEventLogW *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.backup_filename));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.backup_filename");
		return -1;
	}
	object->in.backup_filename = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->in.backup_filename);
	if (object->in.backup_filename == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	PY_CHECK_TYPE(lsa_String_Type, value, return -1;);
	if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	object->in.backup_filename = (struct lsa_String *)pytalloc_get_ptr(value);
	return 0;
}

static PyObject *py_eventlog_BackupEventLogW_get_result(PyObject *obj, void *closure)
{
	struct eventlog_BackupEventLogW *object = (struct eventlog_BackupEventLogW *)pytalloc_get_ptr(obj);
	PyObject *py_result;
	py_result = PyErr_FromNTSTATUS(object->out.result);
	return py_result;
}

static int py_eventlog_BackupEventLogW_set_result(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_BackupEventLogW *object = (struct eventlog_BackupEventLogW *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->out.result");
		return -1;
	}
	object->out.result = NT_STATUS(PyLong_AsLong(value));
	return 0;
}

static PyGetSetDef py_eventlog_BackupEventLogW_getsetters[] = {
	{
		.name = discard_const_p(char, "in_handle"),
		.get = py_eventlog_BackupEventLogW_in_get_handle,
		.set = py_eventlog_BackupEventLogW_in_set_handle,
		.doc = discard_const_p(char, "PIDL-generated element of base type policy_handle")
	},
	{
		.name = discard_const_p(char, "in_backup_filename"),
		.get = py_eventlog_BackupEventLogW_in_get_backup_filename,
		.set = py_eventlog_BackupEventLogW_in_set_backup_filename,
		.doc = discard_const_p(char, "PIDL-generated element of base type lsa_String")
	},
	{
		.name = discard_const_p(char, "result"),
		.get = py_eventlog_BackupEventLogW_get_result,
		.set = py_eventlog_BackupEventLogW_set_result,
		.doc = discard_const_p(char, "PIDL-generated element of type NTSTATUS")
	},
	{ .name = NULL }
};

static PyObject *py_eventlog_BackupEventLogW_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	PyObject *self = pytalloc_new(struct eventlog_BackupEventLogW, type);
	struct eventlog_BackupEventLogW *_self = (struct eventlog_BackupEventLogW *)pytalloc_get_ptr(self);
	TALLOC_CTX *mem_ctx = pytalloc_get_mem_ctx(self);
	_self->in.handle = talloc_zero(mem_ctx, struct policy_handle);
	_self->in.backup_filename = talloc_zero(mem_ctx, struct lsa_String);
	return self;
}

static PyObject *py_eventlog_BackupEventLogW_ndr_opnum(PyTypeObject *type, PyObject *Py_UNUSED(ignored))
{


	return PyLong_FromLong(1);
}

static PyObject *py_eventlog_BackupEventLogW_ndr_pack(PyObject *py_obj, int ndr_inout_flags, uint32_t ndr_push_flags)
{
	const struct ndr_interface_call *call = NULL;
	struct eventlog_BackupEventLogW *object = (struct eventlog_BackupEventLogW *)pytalloc_get_ptr(py_obj);
	PyObject *ret = NULL;
	struct ndr_push *push = NULL;
	DATA_BLOB blob;
	enum ndr_err_code err;

	if (ndr_table_eventlog.num_calls < 2) {
		PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_eventlog_BackupEventLogW_ndr_pack");
		return NULL;
	}
	call = &ndr_table_eventlog.calls[1];

	push = ndr_push_init_ctx(pytalloc_get_mem_ctx(py_obj));
	if (push == NULL) {
		PyErr_SetNdrError(NDR_ERR_ALLOC);
		return NULL;
	}

	push->flags |= ndr_push_flags;

	err = call->ndr_push(push, ndr_inout_flags, object);
	if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
		TALLOC_FREE(push);
		PyErr_SetNdrError(err);
		return NULL;
	}
	blob = ndr_push_blob(push);
	ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
	TALLOC_FREE(push);
	return ret;
}

static PyObject *py_eventlog_BackupEventLogW_ndr_pack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	const char * const kwnames[] = { "bigendian", "ndr64", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_push_flags = 0;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_in__",
		discard_const_p(char *, kwnames),
		&bigendian_obj,
		&ndr64_obj)) {
		return NULL;
	}

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_NDR64;
	}

	return py_eventlog_BackupEventLogW_ndr_pack(py_obj, NDR_IN, ndr_push_flags);
}

static PyObject *py_eventlog_BackupEventLogW_ndr_pack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	const char * const kwnames[] = { "bigendian", "ndr64", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_push_flags = 0;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_out__",
		discard_const_p(char *, kwnames),
		&bigendian_obj,
		&ndr64_obj)) {
		return NULL;
	}

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_NDR64;
	}

	return py_eventlog_BackupEventLogW_ndr_pack(py_obj, NDR_OUT, ndr_push_flags);
}

static PyObject *py_eventlog_BackupEventLogW_ndr_unpack(PyObject *py_obj, const DATA_BLOB *blob, int ndr_inout_flags, uint32_t ndr_pull_flags, bool allow_remaining)
{
	const struct ndr_interface_call *call = NULL;
	struct eventlog_BackupEventLogW *object = (struct eventlog_BackupEventLogW *)pytalloc_get_ptr(py_obj);
	struct ndr_pull *pull = NULL;
	enum ndr_err_code err;

	if (ndr_table_eventlog.num_calls < 2) {
		PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_eventlog_BackupEventLogW_ndr_unpack");
		return NULL;
	}
	call = &ndr_table_eventlog.calls[1];

	pull = ndr_pull_init_blob(blob, object);
	if (pull == NULL) {
		PyErr_SetNdrError(NDR_ERR_ALLOC);
		return NULL;
	}

	pull->flags |= ndr_pull_flags;

	err = call->ndr_pull(pull, ndr_inout_flags, object);
	if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
		TALLOC_FREE(pull);
		PyErr_SetNdrError(err);
		return NULL;
	}
	if (!allow_remaining) {
		uint32_t highest_ofs;

		if (pull->offset > pull->relative_highest_offset) {
			highest_ofs = pull->offset;
		} else {
			highest_ofs = pull->relative_highest_offset;
		}
		if (highest_ofs < pull->data_size) {
			err = ndr_pull_error(pull, NDR_ERR_UNREAD_BYTES,
				"not all bytes consumed ofs[%u] size[%u]",
				highest_ofs, pull->data_size);
			TALLOC_FREE(pull);
			PyErr_SetNdrError(err);
			return NULL;
		}
	}

	TALLOC_FREE(pull);
	Py_RETURN_NONE;
}

static PyObject *py_eventlog_BackupEventLogW_ndr_unpack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	DATA_BLOB blob;
	Py_ssize_t blob_length = 0;
	const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
	PyObject *allow_remaining_obj = NULL;
	bool allow_remaining = false;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_in__",
		discard_const_p(char *, kwnames),
		&blob.data, &blob_length,
		&bigendian_obj,
		&ndr64_obj,
		&allow_remaining_obj)) {
		return NULL;
	}
	blob.length = blob_length;

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_NDR64;
	}

	if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
		allow_remaining = true;
	}

	return py_eventlog_BackupEventLogW_ndr_unpack(py_obj, &blob, NDR_IN, ndr_pull_flags, allow_remaining);
}

static PyObject *py_eventlog_BackupEventLogW_ndr_unpack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	DATA_BLOB blob;
	Py_ssize_t blob_length = 0;
	const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
	PyObject *allow_remaining_obj = NULL;
	bool allow_remaining = false;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_out__",
		discard_const_p(char *, kwnames),
		&blob.data, &blob_length,
		&bigendian_obj,
		&ndr64_obj,
		&allow_remaining_obj)) {
		return NULL;
	}
	blob.length = blob_length;

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_NDR64;
	}

	if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
		allow_remaining = true;
	}

	return py_eventlog_BackupEventLogW_ndr_unpack(py_obj, &blob, NDR_OUT, ndr_pull_flags, allow_remaining);
}

static PyObject *py_eventlog_BackupEventLogW_ndr_print(PyObject *py_obj, const char *name, int ndr_inout_flags)
{
	const struct ndr_interface_call *call = NULL;
	struct eventlog_BackupEventLogW *object = (struct eventlog_BackupEventLogW *)pytalloc_get_ptr(py_obj);
	PyObject *ret;
	char *retstr;

	if (ndr_table_eventlog.num_calls < 2) {
		PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_eventlog_BackupEventLogW_ndr_print");
		return NULL;
	}
	call = &ndr_table_eventlog.calls[1];

	retstr = ndr_print_function_string(pytalloc_get_mem_ctx(py_obj), call->ndr_print, name, ndr_inout_flags, object);
	ret = PyUnicode_FromString(retstr);
	TALLOC_FREE(retstr);

	return ret;
}

static PyObject *py_eventlog_BackupEventLogW_ndr_print_in(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
{
	return py_eventlog_BackupEventLogW_ndr_print(py_obj, "eventlog_BackupEventLogW_in", NDR_IN);
}

static PyObject *py_eventlog_BackupEventLogW_ndr_print_out(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
{
	return py_eventlog_BackupEventLogW_ndr_print(py_obj, "eventlog_BackupEventLogW_out", NDR_OUT);
}

static PyMethodDef py_eventlog_BackupEventLogW_methods[] = {
	{ "opnum", (PyCFunction)py_eventlog_BackupEventLogW_ndr_opnum, METH_NOARGS|METH_CLASS,
		"eventlog.BackupEventLogW.opnum() -> 1 (0x01) " },
	{ "__ndr_pack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_BackupEventLogW_ndr_pack_in), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_pack_in(object, bigendian=False, ndr64=False) -> blob\nNDR pack input" },
	{ "__ndr_pack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_BackupEventLogW_ndr_pack_out), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_pack_out(object, bigendian=False, ndr64=False) -> blob\nNDR pack output" },
	{ "__ndr_unpack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_BackupEventLogW_ndr_unpack_in), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_unpack_in(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack input" },
	{ "__ndr_unpack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_BackupEventLogW_ndr_unpack_out), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_unpack_out(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack output" },
	{ "__ndr_print_in__", (PyCFunction)py_eventlog_BackupEventLogW_ndr_print_in, METH_NOARGS, "S.ndr_print_in(object) -> None\nNDR print input" },
	{ "__ndr_print_out__", (PyCFunction)py_eventlog_BackupEventLogW_ndr_print_out, METH_NOARGS, "S.ndr_print_out(object) -> None\nNDR print output" },
	{ NULL, NULL, 0, NULL }
};


static PyTypeObject eventlog_BackupEventLogW_Type = {
	PyVarObject_HEAD_INIT(NULL, 0)
	.tp_name = "eventlog.BackupEventLogW",
	.tp_getset = py_eventlog_BackupEventLogW_getsetters,
	.tp_methods = py_eventlog_BackupEventLogW_methods,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_new = py_eventlog_BackupEventLogW_new,
};

static bool pack_py_eventlog_BackupEventLogW_args_in(PyObject *args, PyObject *kwargs, struct eventlog_BackupEventLogW *r)
{
	PyObject *py_handle;
	PyObject *py_backup_filename;
	const char *kwnames[] = {
		"handle", "backup_filename", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:eventlog_BackupEventLogW", discard_const_p(char *, kwnames), &py_handle, &py_backup_filename)) {
		return false;
	}

	if (py_handle == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.handle");
		return false;
	}
	r->in.handle = talloc_ptrtype(r, r->in.handle);
	if (r->in.handle == NULL) {
		PyErr_NoMemory();
		return false;
	}
	PY_CHECK_TYPE(policy_handle_Type, py_handle, return false;);
	if (talloc_reference(r, pytalloc_get_mem_ctx(py_handle)) == NULL) {
		PyErr_NoMemory();
		return false;
	}
	r->in.handle = (struct policy_handle *)pytalloc_get_ptr(py_handle);
	if (py_backup_filename == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.backup_filename");
		return false;
	}
	r->in.backup_filename = talloc_ptrtype(r, r->in.backup_filename);
	if (r->in.backup_filename == NULL) {
		PyErr_NoMemory();
		return false;
	}
	PY_CHECK_TYPE(lsa_String_Type, py_backup_filename, return false;);
	if (talloc_reference(r, pytalloc_get_mem_ctx(py_backup_filename)) == NULL) {
		PyErr_NoMemory();
		return false;
	}
	r->in.backup_filename = (struct lsa_String *)pytalloc_get_ptr(py_backup_filename);
	return true;
}

static PyObject *unpack_py_eventlog_BackupEventLogW_args_out(struct eventlog_BackupEventLogW *r)
{
	PyObject *result;
	result = Py_None;
	Py_INCREF(result);
	if (NT_STATUS_IS_ERR(r->out.result)) {
		PyErr_SetNTSTATUS(r->out.result);
		return NULL;
	}

	return result;
}


static PyObject *py_eventlog_CloseEventLog_in_get_handle(PyObject *obj, void *closure)
{
	struct eventlog_CloseEventLog *object = (struct eventlog_CloseEventLog *)pytalloc_get_ptr(obj);
	PyObject *py_handle;
	if (object->in.handle == NULL) {
		Py_RETURN_NONE;
	}
	py_handle = pytalloc_reference_ex(policy_handle_Type, object->in.handle, object->in.handle);
	return py_handle;
}

static int py_eventlog_CloseEventLog_in_set_handle(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_CloseEventLog *object = (struct eventlog_CloseEventLog *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.handle));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.handle");
		return -1;
	}
	object->in.handle = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->in.handle);
	if (object->in.handle == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	PY_CHECK_TYPE(policy_handle_Type, value, return -1;);
	if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	object->in.handle = (struct policy_handle *)pytalloc_get_ptr(value);
	return 0;
}

static PyObject *py_eventlog_CloseEventLog_out_get_handle(PyObject *obj, void *closure)
{
	struct eventlog_CloseEventLog *object = (struct eventlog_CloseEventLog *)pytalloc_get_ptr(obj);
	PyObject *py_handle;
	if (object->out.handle == NULL) {
		Py_RETURN_NONE;
	}
	py_handle = pytalloc_reference_ex(policy_handle_Type, object->out.handle, object->out.handle);
	return py_handle;
}

static int py_eventlog_CloseEventLog_out_set_handle(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_CloseEventLog *object = (struct eventlog_CloseEventLog *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->out.handle));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->out.handle");
		return -1;
	}
	object->out.handle = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->out.handle);
	if (object->out.handle == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	PY_CHECK_TYPE(policy_handle_Type, value, return -1;);
	if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	object->out.handle = (struct policy_handle *)pytalloc_get_ptr(value);
	return 0;
}

static PyObject *py_eventlog_CloseEventLog_get_result(PyObject *obj, void *closure)
{
	struct eventlog_CloseEventLog *object = (struct eventlog_CloseEventLog *)pytalloc_get_ptr(obj);
	PyObject *py_result;
	py_result = PyErr_FromNTSTATUS(object->out.result);
	return py_result;
}

static int py_eventlog_CloseEventLog_set_result(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_CloseEventLog *object = (struct eventlog_CloseEventLog *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->out.result");
		return -1;
	}
	object->out.result = NT_STATUS(PyLong_AsLong(value));
	return 0;
}

static PyGetSetDef py_eventlog_CloseEventLog_getsetters[] = {
	{
		.name = discard_const_p(char, "in_handle"),
		.get = py_eventlog_CloseEventLog_in_get_handle,
		.set = py_eventlog_CloseEventLog_in_set_handle,
		.doc = discard_const_p(char, "PIDL-generated element of base type policy_handle")
	},
	{
		.name = discard_const_p(char, "out_handle"),
		.get = py_eventlog_CloseEventLog_out_get_handle,
		.set = py_eventlog_CloseEventLog_out_set_handle,
		.doc = discard_const_p(char, "PIDL-generated element of base type policy_handle")
	},
	{
		.name = discard_const_p(char, "result"),
		.get = py_eventlog_CloseEventLog_get_result,
		.set = py_eventlog_CloseEventLog_set_result,
		.doc = discard_const_p(char, "PIDL-generated element of type NTSTATUS")
	},
	{ .name = NULL }
};

static PyObject *py_eventlog_CloseEventLog_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	PyObject *self = pytalloc_new(struct eventlog_CloseEventLog, type);
	struct eventlog_CloseEventLog *_self = (struct eventlog_CloseEventLog *)pytalloc_get_ptr(self);
	TALLOC_CTX *mem_ctx = pytalloc_get_mem_ctx(self);
	_self->in.handle = talloc_zero(mem_ctx, struct policy_handle);
	_self->out.handle = talloc_zero(mem_ctx, struct policy_handle);
	return self;
}

static PyObject *py_eventlog_CloseEventLog_ndr_opnum(PyTypeObject *type, PyObject *Py_UNUSED(ignored))
{


	return PyLong_FromLong(2);
}

static PyObject *py_eventlog_CloseEventLog_ndr_pack(PyObject *py_obj, int ndr_inout_flags, uint32_t ndr_push_flags)
{
	const struct ndr_interface_call *call = NULL;
	struct eventlog_CloseEventLog *object = (struct eventlog_CloseEventLog *)pytalloc_get_ptr(py_obj);
	PyObject *ret = NULL;
	struct ndr_push *push = NULL;
	DATA_BLOB blob;
	enum ndr_err_code err;

	if (ndr_table_eventlog.num_calls < 3) {
		PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_eventlog_CloseEventLog_ndr_pack");
		return NULL;
	}
	call = &ndr_table_eventlog.calls[2];

	push = ndr_push_init_ctx(pytalloc_get_mem_ctx(py_obj));
	if (push == NULL) {
		PyErr_SetNdrError(NDR_ERR_ALLOC);
		return NULL;
	}

	push->flags |= ndr_push_flags;

	err = call->ndr_push(push, ndr_inout_flags, object);
	if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
		TALLOC_FREE(push);
		PyErr_SetNdrError(err);
		return NULL;
	}
	blob = ndr_push_blob(push);
	ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
	TALLOC_FREE(push);
	return ret;
}

static PyObject *py_eventlog_CloseEventLog_ndr_pack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	const char * const kwnames[] = { "bigendian", "ndr64", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_push_flags = 0;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_in__",
		discard_const_p(char *, kwnames),
		&bigendian_obj,
		&ndr64_obj)) {
		return NULL;
	}

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_NDR64;
	}

	return py_eventlog_CloseEventLog_ndr_pack(py_obj, NDR_IN, ndr_push_flags);
}

static PyObject *py_eventlog_CloseEventLog_ndr_pack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	const char * const kwnames[] = { "bigendian", "ndr64", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_push_flags = 0;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_out__",
		discard_const_p(char *, kwnames),
		&bigendian_obj,
		&ndr64_obj)) {
		return NULL;
	}

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_NDR64;
	}

	return py_eventlog_CloseEventLog_ndr_pack(py_obj, NDR_OUT, ndr_push_flags);
}

static PyObject *py_eventlog_CloseEventLog_ndr_unpack(PyObject *py_obj, const DATA_BLOB *blob, int ndr_inout_flags, uint32_t ndr_pull_flags, bool allow_remaining)
{
	const struct ndr_interface_call *call = NULL;
	struct eventlog_CloseEventLog *object = (struct eventlog_CloseEventLog *)pytalloc_get_ptr(py_obj);
	struct ndr_pull *pull = NULL;
	enum ndr_err_code err;

	if (ndr_table_eventlog.num_calls < 3) {
		PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_eventlog_CloseEventLog_ndr_unpack");
		return NULL;
	}
	call = &ndr_table_eventlog.calls[2];

	pull = ndr_pull_init_blob(blob, object);
	if (pull == NULL) {
		PyErr_SetNdrError(NDR_ERR_ALLOC);
		return NULL;
	}

	pull->flags |= ndr_pull_flags;

	err = call->ndr_pull(pull, ndr_inout_flags, object);
	if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
		TALLOC_FREE(pull);
		PyErr_SetNdrError(err);
		return NULL;
	}
	if (!allow_remaining) {
		uint32_t highest_ofs;

		if (pull->offset > pull->relative_highest_offset) {
			highest_ofs = pull->offset;
		} else {
			highest_ofs = pull->relative_highest_offset;
		}
		if (highest_ofs < pull->data_size) {
			err = ndr_pull_error(pull, NDR_ERR_UNREAD_BYTES,
				"not all bytes consumed ofs[%u] size[%u]",
				highest_ofs, pull->data_size);
			TALLOC_FREE(pull);
			PyErr_SetNdrError(err);
			return NULL;
		}
	}

	TALLOC_FREE(pull);
	Py_RETURN_NONE;
}

static PyObject *py_eventlog_CloseEventLog_ndr_unpack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	DATA_BLOB blob;
	Py_ssize_t blob_length = 0;
	const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
	PyObject *allow_remaining_obj = NULL;
	bool allow_remaining = false;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_in__",
		discard_const_p(char *, kwnames),
		&blob.data, &blob_length,
		&bigendian_obj,
		&ndr64_obj,
		&allow_remaining_obj)) {
		return NULL;
	}
	blob.length = blob_length;

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_NDR64;
	}

	if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
		allow_remaining = true;
	}

	return py_eventlog_CloseEventLog_ndr_unpack(py_obj, &blob, NDR_IN, ndr_pull_flags, allow_remaining);
}

static PyObject *py_eventlog_CloseEventLog_ndr_unpack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	DATA_BLOB blob;
	Py_ssize_t blob_length = 0;
	const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
	PyObject *allow_remaining_obj = NULL;
	bool allow_remaining = false;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_out__",
		discard_const_p(char *, kwnames),
		&blob.data, &blob_length,
		&bigendian_obj,
		&ndr64_obj,
		&allow_remaining_obj)) {
		return NULL;
	}
	blob.length = blob_length;

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_NDR64;
	}

	if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
		allow_remaining = true;
	}

	return py_eventlog_CloseEventLog_ndr_unpack(py_obj, &blob, NDR_OUT, ndr_pull_flags, allow_remaining);
}

static PyObject *py_eventlog_CloseEventLog_ndr_print(PyObject *py_obj, const char *name, int ndr_inout_flags)
{
	const struct ndr_interface_call *call = NULL;
	struct eventlog_CloseEventLog *object = (struct eventlog_CloseEventLog *)pytalloc_get_ptr(py_obj);
	PyObject *ret;
	char *retstr;

	if (ndr_table_eventlog.num_calls < 3) {
		PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_eventlog_CloseEventLog_ndr_print");
		return NULL;
	}
	call = &ndr_table_eventlog.calls[2];

	retstr = ndr_print_function_string(pytalloc_get_mem_ctx(py_obj), call->ndr_print, name, ndr_inout_flags, object);
	ret = PyUnicode_FromString(retstr);
	TALLOC_FREE(retstr);

	return ret;
}

static PyObject *py_eventlog_CloseEventLog_ndr_print_in(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
{
	return py_eventlog_CloseEventLog_ndr_print(py_obj, "eventlog_CloseEventLog_in", NDR_IN);
}

static PyObject *py_eventlog_CloseEventLog_ndr_print_out(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
{
	return py_eventlog_CloseEventLog_ndr_print(py_obj, "eventlog_CloseEventLog_out", NDR_OUT);
}

static PyMethodDef py_eventlog_CloseEventLog_methods[] = {
	{ "opnum", (PyCFunction)py_eventlog_CloseEventLog_ndr_opnum, METH_NOARGS|METH_CLASS,
		"eventlog.CloseEventLog.opnum() -> 2 (0x02) " },
	{ "__ndr_pack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_CloseEventLog_ndr_pack_in), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_pack_in(object, bigendian=False, ndr64=False) -> blob\nNDR pack input" },
	{ "__ndr_pack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_CloseEventLog_ndr_pack_out), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_pack_out(object, bigendian=False, ndr64=False) -> blob\nNDR pack output" },
	{ "__ndr_unpack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_CloseEventLog_ndr_unpack_in), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_unpack_in(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack input" },
	{ "__ndr_unpack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_CloseEventLog_ndr_unpack_out), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_unpack_out(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack output" },
	{ "__ndr_print_in__", (PyCFunction)py_eventlog_CloseEventLog_ndr_print_in, METH_NOARGS, "S.ndr_print_in(object) -> None\nNDR print input" },
	{ "__ndr_print_out__", (PyCFunction)py_eventlog_CloseEventLog_ndr_print_out, METH_NOARGS, "S.ndr_print_out(object) -> None\nNDR print output" },
	{ NULL, NULL, 0, NULL }
};


static PyTypeObject eventlog_CloseEventLog_Type = {
	PyVarObject_HEAD_INIT(NULL, 0)
	.tp_name = "eventlog.CloseEventLog",
	.tp_getset = py_eventlog_CloseEventLog_getsetters,
	.tp_methods = py_eventlog_CloseEventLog_methods,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_new = py_eventlog_CloseEventLog_new,
};

static bool pack_py_eventlog_CloseEventLog_args_in(PyObject *args, PyObject *kwargs, struct eventlog_CloseEventLog *r)
{
	PyObject *py_handle;
	const char *kwnames[] = {
		"handle", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:eventlog_CloseEventLog", discard_const_p(char *, kwnames), &py_handle)) {
		return false;
	}

	if (py_handle == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.handle");
		return false;
	}
	r->in.handle = talloc_ptrtype(r, r->in.handle);
	if (r->in.handle == NULL) {
		PyErr_NoMemory();
		return false;
	}
	PY_CHECK_TYPE(policy_handle_Type, py_handle, return false;);
	if (talloc_reference(r, pytalloc_get_mem_ctx(py_handle)) == NULL) {
		PyErr_NoMemory();
		return false;
	}
	r->in.handle = (struct policy_handle *)pytalloc_get_ptr(py_handle);
	return true;
}

static PyObject *unpack_py_eventlog_CloseEventLog_args_out(struct eventlog_CloseEventLog *r)
{
	PyObject *result;
	PyObject *py_handle;
	py_handle = pytalloc_reference_ex(policy_handle_Type, r->out.handle, r->out.handle);
	result = py_handle;
	if (NT_STATUS_IS_ERR(r->out.result)) {
		PyErr_SetNTSTATUS(r->out.result);
		return NULL;
	}

	return result;
}


static PyObject *py_eventlog_DeregisterEventSource_in_get_handle(PyObject *obj, void *closure)
{
	struct eventlog_DeregisterEventSource *object = (struct eventlog_DeregisterEventSource *)pytalloc_get_ptr(obj);
	PyObject *py_handle;
	if (object->in.handle == NULL) {
		Py_RETURN_NONE;
	}
	py_handle = pytalloc_reference_ex(policy_handle_Type, object->in.handle, object->in.handle);
	return py_handle;
}

static int py_eventlog_DeregisterEventSource_in_set_handle(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_DeregisterEventSource *object = (struct eventlog_DeregisterEventSource *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.handle));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.handle");
		return -1;
	}
	object->in.handle = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->in.handle);
	if (object->in.handle == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	PY_CHECK_TYPE(policy_handle_Type, value, return -1;);
	if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	object->in.handle = (struct policy_handle *)pytalloc_get_ptr(value);
	return 0;
}

static PyObject *py_eventlog_DeregisterEventSource_out_get_handle(PyObject *obj, void *closure)
{
	struct eventlog_DeregisterEventSource *object = (struct eventlog_DeregisterEventSource *)pytalloc_get_ptr(obj);
	PyObject *py_handle;
	if (object->out.handle == NULL) {
		Py_RETURN_NONE;
	}
	py_handle = pytalloc_reference_ex(policy_handle_Type, object->out.handle, object->out.handle);
	return py_handle;
}

static int py_eventlog_DeregisterEventSource_out_set_handle(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_DeregisterEventSource *object = (struct eventlog_DeregisterEventSource *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->out.handle));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->out.handle");
		return -1;
	}
	object->out.handle = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->out.handle);
	if (object->out.handle == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	PY_CHECK_TYPE(policy_handle_Type, value, return -1;);
	if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	object->out.handle = (struct policy_handle *)pytalloc_get_ptr(value);
	return 0;
}

static PyObject *py_eventlog_DeregisterEventSource_get_result(PyObject *obj, void *closure)
{
	struct eventlog_DeregisterEventSource *object = (struct eventlog_DeregisterEventSource *)pytalloc_get_ptr(obj);
	PyObject *py_result;
	py_result = PyErr_FromNTSTATUS(object->out.result);
	return py_result;
}

static int py_eventlog_DeregisterEventSource_set_result(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_DeregisterEventSource *object = (struct eventlog_DeregisterEventSource *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->out.result");
		return -1;
	}
	object->out.result = NT_STATUS(PyLong_AsLong(value));
	return 0;
}

static PyGetSetDef py_eventlog_DeregisterEventSource_getsetters[] = {
	{
		.name = discard_const_p(char, "in_handle"),
		.get = py_eventlog_DeregisterEventSource_in_get_handle,
		.set = py_eventlog_DeregisterEventSource_in_set_handle,
		.doc = discard_const_p(char, "PIDL-generated element of base type policy_handle")
	},
	{
		.name = discard_const_p(char, "out_handle"),
		.get = py_eventlog_DeregisterEventSource_out_get_handle,
		.set = py_eventlog_DeregisterEventSource_out_set_handle,
		.doc = discard_const_p(char, "PIDL-generated element of base type policy_handle")
	},
	{
		.name = discard_const_p(char, "result"),
		.get = py_eventlog_DeregisterEventSource_get_result,
		.set = py_eventlog_DeregisterEventSource_set_result,
		.doc = discard_const_p(char, "PIDL-generated element of type NTSTATUS")
	},
	{ .name = NULL }
};

static PyObject *py_eventlog_DeregisterEventSource_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	PyObject *self = pytalloc_new(struct eventlog_DeregisterEventSource, type);
	struct eventlog_DeregisterEventSource *_self = (struct eventlog_DeregisterEventSource *)pytalloc_get_ptr(self);
	TALLOC_CTX *mem_ctx = pytalloc_get_mem_ctx(self);
	_self->in.handle = talloc_zero(mem_ctx, struct policy_handle);
	_self->out.handle = talloc_zero(mem_ctx, struct policy_handle);
	return self;
}

static PyObject *py_eventlog_DeregisterEventSource_ndr_opnum(PyTypeObject *type, PyObject *Py_UNUSED(ignored))
{


	return PyLong_FromLong(3);
}

static PyObject *py_eventlog_DeregisterEventSource_ndr_pack(PyObject *py_obj, int ndr_inout_flags, uint32_t ndr_push_flags)
{
	const struct ndr_interface_call *call = NULL;
	struct eventlog_DeregisterEventSource *object = (struct eventlog_DeregisterEventSource *)pytalloc_get_ptr(py_obj);
	PyObject *ret = NULL;
	struct ndr_push *push = NULL;
	DATA_BLOB blob;
	enum ndr_err_code err;

	if (ndr_table_eventlog.num_calls < 4) {
		PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_eventlog_DeregisterEventSource_ndr_pack");
		return NULL;
	}
	call = &ndr_table_eventlog.calls[3];

	push = ndr_push_init_ctx(pytalloc_get_mem_ctx(py_obj));
	if (push == NULL) {
		PyErr_SetNdrError(NDR_ERR_ALLOC);
		return NULL;
	}

	push->flags |= ndr_push_flags;

	err = call->ndr_push(push, ndr_inout_flags, object);
	if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
		TALLOC_FREE(push);
		PyErr_SetNdrError(err);
		return NULL;
	}
	blob = ndr_push_blob(push);
	ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
	TALLOC_FREE(push);
	return ret;
}

static PyObject *py_eventlog_DeregisterEventSource_ndr_pack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	const char * const kwnames[] = { "bigendian", "ndr64", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_push_flags = 0;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_in__",
		discard_const_p(char *, kwnames),
		&bigendian_obj,
		&ndr64_obj)) {
		return NULL;
	}

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_NDR64;
	}

	return py_eventlog_DeregisterEventSource_ndr_pack(py_obj, NDR_IN, ndr_push_flags);
}

static PyObject *py_eventlog_DeregisterEventSource_ndr_pack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	const char * const kwnames[] = { "bigendian", "ndr64", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_push_flags = 0;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_out__",
		discard_const_p(char *, kwnames),
		&bigendian_obj,
		&ndr64_obj)) {
		return NULL;
	}

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_NDR64;
	}

	return py_eventlog_DeregisterEventSource_ndr_pack(py_obj, NDR_OUT, ndr_push_flags);
}

static PyObject *py_eventlog_DeregisterEventSource_ndr_unpack(PyObject *py_obj, const DATA_BLOB *blob, int ndr_inout_flags, uint32_t ndr_pull_flags, bool allow_remaining)
{
	const struct ndr_interface_call *call = NULL;
	struct eventlog_DeregisterEventSource *object = (struct eventlog_DeregisterEventSource *)pytalloc_get_ptr(py_obj);
	struct ndr_pull *pull = NULL;
	enum ndr_err_code err;

	if (ndr_table_eventlog.num_calls < 4) {
		PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_eventlog_DeregisterEventSource_ndr_unpack");
		return NULL;
	}
	call = &ndr_table_eventlog.calls[3];

	pull = ndr_pull_init_blob(blob, object);
	if (pull == NULL) {
		PyErr_SetNdrError(NDR_ERR_ALLOC);
		return NULL;
	}

	pull->flags |= ndr_pull_flags;

	err = call->ndr_pull(pull, ndr_inout_flags, object);
	if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
		TALLOC_FREE(pull);
		PyErr_SetNdrError(err);
		return NULL;
	}
	if (!allow_remaining) {
		uint32_t highest_ofs;

		if (pull->offset > pull->relative_highest_offset) {
			highest_ofs = pull->offset;
		} else {
			highest_ofs = pull->relative_highest_offset;
		}
		if (highest_ofs < pull->data_size) {
			err = ndr_pull_error(pull, NDR_ERR_UNREAD_BYTES,
				"not all bytes consumed ofs[%u] size[%u]",
				highest_ofs, pull->data_size);
			TALLOC_FREE(pull);
			PyErr_SetNdrError(err);
			return NULL;
		}
	}

	TALLOC_FREE(pull);
	Py_RETURN_NONE;
}

static PyObject *py_eventlog_DeregisterEventSource_ndr_unpack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	DATA_BLOB blob;
	Py_ssize_t blob_length = 0;
	const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
	PyObject *allow_remaining_obj = NULL;
	bool allow_remaining = false;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_in__",
		discard_const_p(char *, kwnames),
		&blob.data, &blob_length,
		&bigendian_obj,
		&ndr64_obj,
		&allow_remaining_obj)) {
		return NULL;
	}
	blob.length = blob_length;

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_NDR64;
	}

	if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
		allow_remaining = true;
	}

	return py_eventlog_DeregisterEventSource_ndr_unpack(py_obj, &blob, NDR_IN, ndr_pull_flags, allow_remaining);
}

static PyObject *py_eventlog_DeregisterEventSource_ndr_unpack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	DATA_BLOB blob;
	Py_ssize_t blob_length = 0;
	const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
	PyObject *allow_remaining_obj = NULL;
	bool allow_remaining = false;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_out__",
		discard_const_p(char *, kwnames),
		&blob.data, &blob_length,
		&bigendian_obj,
		&ndr64_obj,
		&allow_remaining_obj)) {
		return NULL;
	}
	blob.length = blob_length;

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_NDR64;
	}

	if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
		allow_remaining = true;
	}

	return py_eventlog_DeregisterEventSource_ndr_unpack(py_obj, &blob, NDR_OUT, ndr_pull_flags, allow_remaining);
}

static PyObject *py_eventlog_DeregisterEventSource_ndr_print(PyObject *py_obj, const char *name, int ndr_inout_flags)
{
	const struct ndr_interface_call *call = NULL;
	struct eventlog_DeregisterEventSource *object = (struct eventlog_DeregisterEventSource *)pytalloc_get_ptr(py_obj);
	PyObject *ret;
	char *retstr;

	if (ndr_table_eventlog.num_calls < 4) {
		PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_eventlog_DeregisterEventSource_ndr_print");
		return NULL;
	}
	call = &ndr_table_eventlog.calls[3];

	retstr = ndr_print_function_string(pytalloc_get_mem_ctx(py_obj), call->ndr_print, name, ndr_inout_flags, object);
	ret = PyUnicode_FromString(retstr);
	TALLOC_FREE(retstr);

	return ret;
}

static PyObject *py_eventlog_DeregisterEventSource_ndr_print_in(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
{
	return py_eventlog_DeregisterEventSource_ndr_print(py_obj, "eventlog_DeregisterEventSource_in", NDR_IN);
}

static PyObject *py_eventlog_DeregisterEventSource_ndr_print_out(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
{
	return py_eventlog_DeregisterEventSource_ndr_print(py_obj, "eventlog_DeregisterEventSource_out", NDR_OUT);
}

static PyMethodDef py_eventlog_DeregisterEventSource_methods[] = {
	{ "opnum", (PyCFunction)py_eventlog_DeregisterEventSource_ndr_opnum, METH_NOARGS|METH_CLASS,
		"eventlog.DeregisterEventSource.opnum() -> 3 (0x03) " },
	{ "__ndr_pack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_DeregisterEventSource_ndr_pack_in), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_pack_in(object, bigendian=False, ndr64=False) -> blob\nNDR pack input" },
	{ "__ndr_pack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_DeregisterEventSource_ndr_pack_out), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_pack_out(object, bigendian=False, ndr64=False) -> blob\nNDR pack output" },
	{ "__ndr_unpack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_DeregisterEventSource_ndr_unpack_in), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_unpack_in(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack input" },
	{ "__ndr_unpack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_DeregisterEventSource_ndr_unpack_out), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_unpack_out(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack output" },
	{ "__ndr_print_in__", (PyCFunction)py_eventlog_DeregisterEventSource_ndr_print_in, METH_NOARGS, "S.ndr_print_in(object) -> None\nNDR print input" },
	{ "__ndr_print_out__", (PyCFunction)py_eventlog_DeregisterEventSource_ndr_print_out, METH_NOARGS, "S.ndr_print_out(object) -> None\nNDR print output" },
	{ NULL, NULL, 0, NULL }
};


static PyTypeObject eventlog_DeregisterEventSource_Type = {
	PyVarObject_HEAD_INIT(NULL, 0)
	.tp_name = "eventlog.DeregisterEventSource",
	.tp_getset = py_eventlog_DeregisterEventSource_getsetters,
	.tp_methods = py_eventlog_DeregisterEventSource_methods,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_new = py_eventlog_DeregisterEventSource_new,
};

static bool pack_py_eventlog_DeregisterEventSource_args_in(PyObject *args, PyObject *kwargs, struct eventlog_DeregisterEventSource *r)
{
	PyObject *py_handle;
	const char *kwnames[] = {
		"handle", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:eventlog_DeregisterEventSource", discard_const_p(char *, kwnames), &py_handle)) {
		return false;
	}

	if (py_handle == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.handle");
		return false;
	}
	r->in.handle = talloc_ptrtype(r, r->in.handle);
	if (r->in.handle == NULL) {
		PyErr_NoMemory();
		return false;
	}
	PY_CHECK_TYPE(policy_handle_Type, py_handle, return false;);
	if (talloc_reference(r, pytalloc_get_mem_ctx(py_handle)) == NULL) {
		PyErr_NoMemory();
		return false;
	}
	r->in.handle = (struct policy_handle *)pytalloc_get_ptr(py_handle);
	return true;
}

static PyObject *unpack_py_eventlog_DeregisterEventSource_args_out(struct eventlog_DeregisterEventSource *r)
{
	PyObject *result;
	PyObject *py_handle;
	py_handle = pytalloc_reference_ex(policy_handle_Type, r->out.handle, r->out.handle);
	result = py_handle;
	if (NT_STATUS_IS_ERR(r->out.result)) {
		PyErr_SetNTSTATUS(r->out.result);
		return NULL;
	}

	return result;
}


static PyObject *py_eventlog_GetNumRecords_in_get_handle(PyObject *obj, void *closure)
{
	struct eventlog_GetNumRecords *object = (struct eventlog_GetNumRecords *)pytalloc_get_ptr(obj);
	PyObject *py_handle;
	if (object->in.handle == NULL) {
		Py_RETURN_NONE;
	}
	py_handle = pytalloc_reference_ex(policy_handle_Type, object->in.handle, object->in.handle);
	return py_handle;
}

static int py_eventlog_GetNumRecords_in_set_handle(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_GetNumRecords *object = (struct eventlog_GetNumRecords *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.handle));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.handle");
		return -1;
	}
	object->in.handle = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->in.handle);
	if (object->in.handle == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	PY_CHECK_TYPE(policy_handle_Type, value, return -1;);
	if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	object->in.handle = (struct policy_handle *)pytalloc_get_ptr(value);
	return 0;
}

static PyObject *py_eventlog_GetNumRecords_out_get_number(PyObject *obj, void *closure)
{
	struct eventlog_GetNumRecords *object = (struct eventlog_GetNumRecords *)pytalloc_get_ptr(obj);
	PyObject *py_number;
	if (object->out.number == NULL) {
		Py_RETURN_NONE;
	}
	py_number = PyLong_FromUnsignedLongLong((uint32_t)*object->out.number);
	return py_number;
}

static int py_eventlog_GetNumRecords_out_set_number(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_GetNumRecords *object = (struct eventlog_GetNumRecords *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->out.number));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->out.number");
		return -1;
	}
	object->out.number = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->out.number);
	if (object->out.number == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(*object->out.number));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			*object->out.number = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_GetNumRecords_get_result(PyObject *obj, void *closure)
{
	struct eventlog_GetNumRecords *object = (struct eventlog_GetNumRecords *)pytalloc_get_ptr(obj);
	PyObject *py_result;
	py_result = PyErr_FromNTSTATUS(object->out.result);
	return py_result;
}

static int py_eventlog_GetNumRecords_set_result(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_GetNumRecords *object = (struct eventlog_GetNumRecords *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->out.result");
		return -1;
	}
	object->out.result = NT_STATUS(PyLong_AsLong(value));
	return 0;
}

static PyGetSetDef py_eventlog_GetNumRecords_getsetters[] = {
	{
		.name = discard_const_p(char, "in_handle"),
		.get = py_eventlog_GetNumRecords_in_get_handle,
		.set = py_eventlog_GetNumRecords_in_set_handle,
		.doc = discard_const_p(char, "PIDL-generated element of base type policy_handle")
	},
	{
		.name = discard_const_p(char, "out_number"),
		.get = py_eventlog_GetNumRecords_out_get_number,
		.set = py_eventlog_GetNumRecords_out_set_number,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "result"),
		.get = py_eventlog_GetNumRecords_get_result,
		.set = py_eventlog_GetNumRecords_set_result,
		.doc = discard_const_p(char, "PIDL-generated element of type NTSTATUS")
	},
	{ .name = NULL }
};

static PyObject *py_eventlog_GetNumRecords_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	PyObject *self = pytalloc_new(struct eventlog_GetNumRecords, type);
	struct eventlog_GetNumRecords *_self = (struct eventlog_GetNumRecords *)pytalloc_get_ptr(self);
	TALLOC_CTX *mem_ctx = pytalloc_get_mem_ctx(self);
	_self->in.handle = talloc_zero(mem_ctx, struct policy_handle);
	_self->out.number = talloc_zero(mem_ctx, uint32_t);
	return self;
}

static PyObject *py_eventlog_GetNumRecords_ndr_opnum(PyTypeObject *type, PyObject *Py_UNUSED(ignored))
{


	return PyLong_FromLong(4);
}

static PyObject *py_eventlog_GetNumRecords_ndr_pack(PyObject *py_obj, int ndr_inout_flags, uint32_t ndr_push_flags)
{
	const struct ndr_interface_call *call = NULL;
	struct eventlog_GetNumRecords *object = (struct eventlog_GetNumRecords *)pytalloc_get_ptr(py_obj);
	PyObject *ret = NULL;
	struct ndr_push *push = NULL;
	DATA_BLOB blob;
	enum ndr_err_code err;

	if (ndr_table_eventlog.num_calls < 5) {
		PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_eventlog_GetNumRecords_ndr_pack");
		return NULL;
	}
	call = &ndr_table_eventlog.calls[4];

	push = ndr_push_init_ctx(pytalloc_get_mem_ctx(py_obj));
	if (push == NULL) {
		PyErr_SetNdrError(NDR_ERR_ALLOC);
		return NULL;
	}

	push->flags |= ndr_push_flags;

	err = call->ndr_push(push, ndr_inout_flags, object);
	if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
		TALLOC_FREE(push);
		PyErr_SetNdrError(err);
		return NULL;
	}
	blob = ndr_push_blob(push);
	ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
	TALLOC_FREE(push);
	return ret;
}

static PyObject *py_eventlog_GetNumRecords_ndr_pack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	const char * const kwnames[] = { "bigendian", "ndr64", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_push_flags = 0;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_in__",
		discard_const_p(char *, kwnames),
		&bigendian_obj,
		&ndr64_obj)) {
		return NULL;
	}

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_NDR64;
	}

	return py_eventlog_GetNumRecords_ndr_pack(py_obj, NDR_IN, ndr_push_flags);
}

static PyObject *py_eventlog_GetNumRecords_ndr_pack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	const char * const kwnames[] = { "bigendian", "ndr64", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_push_flags = 0;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_out__",
		discard_const_p(char *, kwnames),
		&bigendian_obj,
		&ndr64_obj)) {
		return NULL;
	}

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_NDR64;
	}

	return py_eventlog_GetNumRecords_ndr_pack(py_obj, NDR_OUT, ndr_push_flags);
}

static PyObject *py_eventlog_GetNumRecords_ndr_unpack(PyObject *py_obj, const DATA_BLOB *blob, int ndr_inout_flags, uint32_t ndr_pull_flags, bool allow_remaining)
{
	const struct ndr_interface_call *call = NULL;
	struct eventlog_GetNumRecords *object = (struct eventlog_GetNumRecords *)pytalloc_get_ptr(py_obj);
	struct ndr_pull *pull = NULL;
	enum ndr_err_code err;

	if (ndr_table_eventlog.num_calls < 5) {
		PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_eventlog_GetNumRecords_ndr_unpack");
		return NULL;
	}
	call = &ndr_table_eventlog.calls[4];

	pull = ndr_pull_init_blob(blob, object);
	if (pull == NULL) {
		PyErr_SetNdrError(NDR_ERR_ALLOC);
		return NULL;
	}

	pull->flags |= ndr_pull_flags;

	err = call->ndr_pull(pull, ndr_inout_flags, object);
	if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
		TALLOC_FREE(pull);
		PyErr_SetNdrError(err);
		return NULL;
	}
	if (!allow_remaining) {
		uint32_t highest_ofs;

		if (pull->offset > pull->relative_highest_offset) {
			highest_ofs = pull->offset;
		} else {
			highest_ofs = pull->relative_highest_offset;
		}
		if (highest_ofs < pull->data_size) {
			err = ndr_pull_error(pull, NDR_ERR_UNREAD_BYTES,
				"not all bytes consumed ofs[%u] size[%u]",
				highest_ofs, pull->data_size);
			TALLOC_FREE(pull);
			PyErr_SetNdrError(err);
			return NULL;
		}
	}

	TALLOC_FREE(pull);
	Py_RETURN_NONE;
}

static PyObject *py_eventlog_GetNumRecords_ndr_unpack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	DATA_BLOB blob;
	Py_ssize_t blob_length = 0;
	const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
	PyObject *allow_remaining_obj = NULL;
	bool allow_remaining = false;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_in__",
		discard_const_p(char *, kwnames),
		&blob.data, &blob_length,
		&bigendian_obj,
		&ndr64_obj,
		&allow_remaining_obj)) {
		return NULL;
	}
	blob.length = blob_length;

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_NDR64;
	}

	if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
		allow_remaining = true;
	}

	return py_eventlog_GetNumRecords_ndr_unpack(py_obj, &blob, NDR_IN, ndr_pull_flags, allow_remaining);
}

static PyObject *py_eventlog_GetNumRecords_ndr_unpack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	DATA_BLOB blob;
	Py_ssize_t blob_length = 0;
	const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
	PyObject *allow_remaining_obj = NULL;
	bool allow_remaining = false;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_out__",
		discard_const_p(char *, kwnames),
		&blob.data, &blob_length,
		&bigendian_obj,
		&ndr64_obj,
		&allow_remaining_obj)) {
		return NULL;
	}
	blob.length = blob_length;

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_NDR64;
	}

	if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
		allow_remaining = true;
	}

	return py_eventlog_GetNumRecords_ndr_unpack(py_obj, &blob, NDR_OUT, ndr_pull_flags, allow_remaining);
}

static PyObject *py_eventlog_GetNumRecords_ndr_print(PyObject *py_obj, const char *name, int ndr_inout_flags)
{
	const struct ndr_interface_call *call = NULL;
	struct eventlog_GetNumRecords *object = (struct eventlog_GetNumRecords *)pytalloc_get_ptr(py_obj);
	PyObject *ret;
	char *retstr;

	if (ndr_table_eventlog.num_calls < 5) {
		PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_eventlog_GetNumRecords_ndr_print");
		return NULL;
	}
	call = &ndr_table_eventlog.calls[4];

	retstr = ndr_print_function_string(pytalloc_get_mem_ctx(py_obj), call->ndr_print, name, ndr_inout_flags, object);
	ret = PyUnicode_FromString(retstr);
	TALLOC_FREE(retstr);

	return ret;
}

static PyObject *py_eventlog_GetNumRecords_ndr_print_in(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
{
	return py_eventlog_GetNumRecords_ndr_print(py_obj, "eventlog_GetNumRecords_in", NDR_IN);
}

static PyObject *py_eventlog_GetNumRecords_ndr_print_out(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
{
	return py_eventlog_GetNumRecords_ndr_print(py_obj, "eventlog_GetNumRecords_out", NDR_OUT);
}

static PyMethodDef py_eventlog_GetNumRecords_methods[] = {
	{ "opnum", (PyCFunction)py_eventlog_GetNumRecords_ndr_opnum, METH_NOARGS|METH_CLASS,
		"eventlog.GetNumRecords.opnum() -> 4 (0x04) " },
	{ "__ndr_pack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_GetNumRecords_ndr_pack_in), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_pack_in(object, bigendian=False, ndr64=False) -> blob\nNDR pack input" },
	{ "__ndr_pack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_GetNumRecords_ndr_pack_out), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_pack_out(object, bigendian=False, ndr64=False) -> blob\nNDR pack output" },
	{ "__ndr_unpack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_GetNumRecords_ndr_unpack_in), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_unpack_in(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack input" },
	{ "__ndr_unpack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_GetNumRecords_ndr_unpack_out), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_unpack_out(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack output" },
	{ "__ndr_print_in__", (PyCFunction)py_eventlog_GetNumRecords_ndr_print_in, METH_NOARGS, "S.ndr_print_in(object) -> None\nNDR print input" },
	{ "__ndr_print_out__", (PyCFunction)py_eventlog_GetNumRecords_ndr_print_out, METH_NOARGS, "S.ndr_print_out(object) -> None\nNDR print output" },
	{ NULL, NULL, 0, NULL }
};


static PyTypeObject eventlog_GetNumRecords_Type = {
	PyVarObject_HEAD_INIT(NULL, 0)
	.tp_name = "eventlog.GetNumRecords",
	.tp_getset = py_eventlog_GetNumRecords_getsetters,
	.tp_methods = py_eventlog_GetNumRecords_methods,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_new = py_eventlog_GetNumRecords_new,
};

static bool pack_py_eventlog_GetNumRecords_args_in(PyObject *args, PyObject *kwargs, struct eventlog_GetNumRecords *r)
{
	PyObject *py_handle;
	const char *kwnames[] = {
		"handle", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:eventlog_GetNumRecords", discard_const_p(char *, kwnames), &py_handle)) {
		return false;
	}

	if (py_handle == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.handle");
		return false;
	}
	r->in.handle = talloc_ptrtype(r, r->in.handle);
	if (r->in.handle == NULL) {
		PyErr_NoMemory();
		return false;
	}
	PY_CHECK_TYPE(policy_handle_Type, py_handle, return false;);
	if (talloc_reference(r, pytalloc_get_mem_ctx(py_handle)) == NULL) {
		PyErr_NoMemory();
		return false;
	}
	r->in.handle = (struct policy_handle *)pytalloc_get_ptr(py_handle);
	return true;
}

static PyObject *unpack_py_eventlog_GetNumRecords_args_out(struct eventlog_GetNumRecords *r)
{
	PyObject *result;
	PyObject *py_number;
	py_number = PyLong_FromUnsignedLongLong((uint32_t)*r->out.number);
	result = py_number;
	if (NT_STATUS_IS_ERR(r->out.result)) {
		PyErr_SetNTSTATUS(r->out.result);
		return NULL;
	}

	return result;
}


static PyObject *py_eventlog_GetOldestRecord_in_get_handle(PyObject *obj, void *closure)
{
	struct eventlog_GetOldestRecord *object = (struct eventlog_GetOldestRecord *)pytalloc_get_ptr(obj);
	PyObject *py_handle;
	if (object->in.handle == NULL) {
		Py_RETURN_NONE;
	}
	py_handle = pytalloc_reference_ex(policy_handle_Type, object->in.handle, object->in.handle);
	return py_handle;
}

static int py_eventlog_GetOldestRecord_in_set_handle(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_GetOldestRecord *object = (struct eventlog_GetOldestRecord *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.handle));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.handle");
		return -1;
	}
	object->in.handle = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->in.handle);
	if (object->in.handle == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	PY_CHECK_TYPE(policy_handle_Type, value, return -1;);
	if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	object->in.handle = (struct policy_handle *)pytalloc_get_ptr(value);
	return 0;
}

static PyObject *py_eventlog_GetOldestRecord_out_get_oldest_entry(PyObject *obj, void *closure)
{
	struct eventlog_GetOldestRecord *object = (struct eventlog_GetOldestRecord *)pytalloc_get_ptr(obj);
	PyObject *py_oldest_entry;
	if (object->out.oldest_entry == NULL) {
		Py_RETURN_NONE;
	}
	py_oldest_entry = PyLong_FromUnsignedLongLong((uint32_t)*object->out.oldest_entry);
	return py_oldest_entry;
}

static int py_eventlog_GetOldestRecord_out_set_oldest_entry(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_GetOldestRecord *object = (struct eventlog_GetOldestRecord *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->out.oldest_entry));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->out.oldest_entry");
		return -1;
	}
	object->out.oldest_entry = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->out.oldest_entry);
	if (object->out.oldest_entry == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(*object->out.oldest_entry));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			*object->out.oldest_entry = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_GetOldestRecord_get_result(PyObject *obj, void *closure)
{
	struct eventlog_GetOldestRecord *object = (struct eventlog_GetOldestRecord *)pytalloc_get_ptr(obj);
	PyObject *py_result;
	py_result = PyErr_FromNTSTATUS(object->out.result);
	return py_result;
}

static int py_eventlog_GetOldestRecord_set_result(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_GetOldestRecord *object = (struct eventlog_GetOldestRecord *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->out.result");
		return -1;
	}
	object->out.result = NT_STATUS(PyLong_AsLong(value));
	return 0;
}

static PyGetSetDef py_eventlog_GetOldestRecord_getsetters[] = {
	{
		.name = discard_const_p(char, "in_handle"),
		.get = py_eventlog_GetOldestRecord_in_get_handle,
		.set = py_eventlog_GetOldestRecord_in_set_handle,
		.doc = discard_const_p(char, "PIDL-generated element of base type policy_handle")
	},
	{
		.name = discard_const_p(char, "out_oldest_entry"),
		.get = py_eventlog_GetOldestRecord_out_get_oldest_entry,
		.set = py_eventlog_GetOldestRecord_out_set_oldest_entry,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "result"),
		.get = py_eventlog_GetOldestRecord_get_result,
		.set = py_eventlog_GetOldestRecord_set_result,
		.doc = discard_const_p(char, "PIDL-generated element of type NTSTATUS")
	},
	{ .name = NULL }
};

static PyObject *py_eventlog_GetOldestRecord_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	PyObject *self = pytalloc_new(struct eventlog_GetOldestRecord, type);
	struct eventlog_GetOldestRecord *_self = (struct eventlog_GetOldestRecord *)pytalloc_get_ptr(self);
	TALLOC_CTX *mem_ctx = pytalloc_get_mem_ctx(self);
	_self->in.handle = talloc_zero(mem_ctx, struct policy_handle);
	_self->out.oldest_entry = talloc_zero(mem_ctx, uint32_t);
	return self;
}

static PyObject *py_eventlog_GetOldestRecord_ndr_opnum(PyTypeObject *type, PyObject *Py_UNUSED(ignored))
{


	return PyLong_FromLong(5);
}

static PyObject *py_eventlog_GetOldestRecord_ndr_pack(PyObject *py_obj, int ndr_inout_flags, uint32_t ndr_push_flags)
{
	const struct ndr_interface_call *call = NULL;
	struct eventlog_GetOldestRecord *object = (struct eventlog_GetOldestRecord *)pytalloc_get_ptr(py_obj);
	PyObject *ret = NULL;
	struct ndr_push *push = NULL;
	DATA_BLOB blob;
	enum ndr_err_code err;

	if (ndr_table_eventlog.num_calls < 6) {
		PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_eventlog_GetOldestRecord_ndr_pack");
		return NULL;
	}
	call = &ndr_table_eventlog.calls[5];

	push = ndr_push_init_ctx(pytalloc_get_mem_ctx(py_obj));
	if (push == NULL) {
		PyErr_SetNdrError(NDR_ERR_ALLOC);
		return NULL;
	}

	push->flags |= ndr_push_flags;

	err = call->ndr_push(push, ndr_inout_flags, object);
	if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
		TALLOC_FREE(push);
		PyErr_SetNdrError(err);
		return NULL;
	}
	blob = ndr_push_blob(push);
	ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
	TALLOC_FREE(push);
	return ret;
}

static PyObject *py_eventlog_GetOldestRecord_ndr_pack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	const char * const kwnames[] = { "bigendian", "ndr64", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_push_flags = 0;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_in__",
		discard_const_p(char *, kwnames),
		&bigendian_obj,
		&ndr64_obj)) {
		return NULL;
	}

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_NDR64;
	}

	return py_eventlog_GetOldestRecord_ndr_pack(py_obj, NDR_IN, ndr_push_flags);
}

static PyObject *py_eventlog_GetOldestRecord_ndr_pack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	const char * const kwnames[] = { "bigendian", "ndr64", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_push_flags = 0;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_out__",
		discard_const_p(char *, kwnames),
		&bigendian_obj,
		&ndr64_obj)) {
		return NULL;
	}

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_NDR64;
	}

	return py_eventlog_GetOldestRecord_ndr_pack(py_obj, NDR_OUT, ndr_push_flags);
}

static PyObject *py_eventlog_GetOldestRecord_ndr_unpack(PyObject *py_obj, const DATA_BLOB *blob, int ndr_inout_flags, uint32_t ndr_pull_flags, bool allow_remaining)
{
	const struct ndr_interface_call *call = NULL;
	struct eventlog_GetOldestRecord *object = (struct eventlog_GetOldestRecord *)pytalloc_get_ptr(py_obj);
	struct ndr_pull *pull = NULL;
	enum ndr_err_code err;

	if (ndr_table_eventlog.num_calls < 6) {
		PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_eventlog_GetOldestRecord_ndr_unpack");
		return NULL;
	}
	call = &ndr_table_eventlog.calls[5];

	pull = ndr_pull_init_blob(blob, object);
	if (pull == NULL) {
		PyErr_SetNdrError(NDR_ERR_ALLOC);
		return NULL;
	}

	pull->flags |= ndr_pull_flags;

	err = call->ndr_pull(pull, ndr_inout_flags, object);
	if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
		TALLOC_FREE(pull);
		PyErr_SetNdrError(err);
		return NULL;
	}
	if (!allow_remaining) {
		uint32_t highest_ofs;

		if (pull->offset > pull->relative_highest_offset) {
			highest_ofs = pull->offset;
		} else {
			highest_ofs = pull->relative_highest_offset;
		}
		if (highest_ofs < pull->data_size) {
			err = ndr_pull_error(pull, NDR_ERR_UNREAD_BYTES,
				"not all bytes consumed ofs[%u] size[%u]",
				highest_ofs, pull->data_size);
			TALLOC_FREE(pull);
			PyErr_SetNdrError(err);
			return NULL;
		}
	}

	TALLOC_FREE(pull);
	Py_RETURN_NONE;
}

static PyObject *py_eventlog_GetOldestRecord_ndr_unpack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	DATA_BLOB blob;
	Py_ssize_t blob_length = 0;
	const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
	PyObject *allow_remaining_obj = NULL;
	bool allow_remaining = false;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_in__",
		discard_const_p(char *, kwnames),
		&blob.data, &blob_length,
		&bigendian_obj,
		&ndr64_obj,
		&allow_remaining_obj)) {
		return NULL;
	}
	blob.length = blob_length;

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_NDR64;
	}

	if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
		allow_remaining = true;
	}

	return py_eventlog_GetOldestRecord_ndr_unpack(py_obj, &blob, NDR_IN, ndr_pull_flags, allow_remaining);
}

static PyObject *py_eventlog_GetOldestRecord_ndr_unpack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	DATA_BLOB blob;
	Py_ssize_t blob_length = 0;
	const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
	PyObject *allow_remaining_obj = NULL;
	bool allow_remaining = false;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_out__",
		discard_const_p(char *, kwnames),
		&blob.data, &blob_length,
		&bigendian_obj,
		&ndr64_obj,
		&allow_remaining_obj)) {
		return NULL;
	}
	blob.length = blob_length;

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_NDR64;
	}

	if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
		allow_remaining = true;
	}

	return py_eventlog_GetOldestRecord_ndr_unpack(py_obj, &blob, NDR_OUT, ndr_pull_flags, allow_remaining);
}

static PyObject *py_eventlog_GetOldestRecord_ndr_print(PyObject *py_obj, const char *name, int ndr_inout_flags)
{
	const struct ndr_interface_call *call = NULL;
	struct eventlog_GetOldestRecord *object = (struct eventlog_GetOldestRecord *)pytalloc_get_ptr(py_obj);
	PyObject *ret;
	char *retstr;

	if (ndr_table_eventlog.num_calls < 6) {
		PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_eventlog_GetOldestRecord_ndr_print");
		return NULL;
	}
	call = &ndr_table_eventlog.calls[5];

	retstr = ndr_print_function_string(pytalloc_get_mem_ctx(py_obj), call->ndr_print, name, ndr_inout_flags, object);
	ret = PyUnicode_FromString(retstr);
	TALLOC_FREE(retstr);

	return ret;
}

static PyObject *py_eventlog_GetOldestRecord_ndr_print_in(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
{
	return py_eventlog_GetOldestRecord_ndr_print(py_obj, "eventlog_GetOldestRecord_in", NDR_IN);
}

static PyObject *py_eventlog_GetOldestRecord_ndr_print_out(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
{
	return py_eventlog_GetOldestRecord_ndr_print(py_obj, "eventlog_GetOldestRecord_out", NDR_OUT);
}

static PyMethodDef py_eventlog_GetOldestRecord_methods[] = {
	{ "opnum", (PyCFunction)py_eventlog_GetOldestRecord_ndr_opnum, METH_NOARGS|METH_CLASS,
		"eventlog.GetOldestRecord.opnum() -> 5 (0x05) " },
	{ "__ndr_pack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_GetOldestRecord_ndr_pack_in), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_pack_in(object, bigendian=False, ndr64=False) -> blob\nNDR pack input" },
	{ "__ndr_pack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_GetOldestRecord_ndr_pack_out), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_pack_out(object, bigendian=False, ndr64=False) -> blob\nNDR pack output" },
	{ "__ndr_unpack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_GetOldestRecord_ndr_unpack_in), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_unpack_in(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack input" },
	{ "__ndr_unpack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_GetOldestRecord_ndr_unpack_out), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_unpack_out(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack output" },
	{ "__ndr_print_in__", (PyCFunction)py_eventlog_GetOldestRecord_ndr_print_in, METH_NOARGS, "S.ndr_print_in(object) -> None\nNDR print input" },
	{ "__ndr_print_out__", (PyCFunction)py_eventlog_GetOldestRecord_ndr_print_out, METH_NOARGS, "S.ndr_print_out(object) -> None\nNDR print output" },
	{ NULL, NULL, 0, NULL }
};


static PyTypeObject eventlog_GetOldestRecord_Type = {
	PyVarObject_HEAD_INIT(NULL, 0)
	.tp_name = "eventlog.GetOldestRecord",
	.tp_getset = py_eventlog_GetOldestRecord_getsetters,
	.tp_methods = py_eventlog_GetOldestRecord_methods,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_new = py_eventlog_GetOldestRecord_new,
};

static bool pack_py_eventlog_GetOldestRecord_args_in(PyObject *args, PyObject *kwargs, struct eventlog_GetOldestRecord *r)
{
	PyObject *py_handle;
	const char *kwnames[] = {
		"handle", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:eventlog_GetOldestRecord", discard_const_p(char *, kwnames), &py_handle)) {
		return false;
	}

	if (py_handle == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.handle");
		return false;
	}
	r->in.handle = talloc_ptrtype(r, r->in.handle);
	if (r->in.handle == NULL) {
		PyErr_NoMemory();
		return false;
	}
	PY_CHECK_TYPE(policy_handle_Type, py_handle, return false;);
	if (talloc_reference(r, pytalloc_get_mem_ctx(py_handle)) == NULL) {
		PyErr_NoMemory();
		return false;
	}
	r->in.handle = (struct policy_handle *)pytalloc_get_ptr(py_handle);
	return true;
}

static PyObject *unpack_py_eventlog_GetOldestRecord_args_out(struct eventlog_GetOldestRecord *r)
{
	PyObject *result;
	PyObject *py_oldest_entry;
	py_oldest_entry = PyLong_FromUnsignedLongLong((uint32_t)*r->out.oldest_entry);
	result = py_oldest_entry;
	if (NT_STATUS_IS_ERR(r->out.result)) {
		PyErr_SetNTSTATUS(r->out.result);
		return NULL;
	}

	return result;
}


static PyObject *py_eventlog_OpenEventLogW_in_get_unknown0(PyObject *obj, void *closure)
{
	struct eventlog_OpenEventLogW *object = (struct eventlog_OpenEventLogW *)pytalloc_get_ptr(obj);
	PyObject *py_unknown0;
	if (object->in.unknown0 == NULL) {
		Py_RETURN_NONE;
	}
	if (object->in.unknown0 == NULL) {
		py_unknown0 = Py_None;
		Py_INCREF(py_unknown0);
	} else {
		py_unknown0 = pytalloc_reference_ex(&eventlog_OpenUnknown0_Type, object->in.unknown0, object->in.unknown0);
	}
	return py_unknown0;
}

static int py_eventlog_OpenEventLogW_in_set_unknown0(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_OpenEventLogW *object = (struct eventlog_OpenEventLogW *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.unknown0));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.unknown0");
		return -1;
	}
	if (value == Py_None) {
		object->in.unknown0 = NULL;
	} else {
		object->in.unknown0 = NULL;
		PY_CHECK_TYPE(&eventlog_OpenUnknown0_Type, value, return -1;);
		if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
			PyErr_NoMemory();
			return -1;
		}
		object->in.unknown0 = (struct eventlog_OpenUnknown0 *)pytalloc_get_ptr(value);
	}
	return 0;
}

static PyObject *py_eventlog_OpenEventLogW_in_get_logname(PyObject *obj, void *closure)
{
	struct eventlog_OpenEventLogW *object = (struct eventlog_OpenEventLogW *)pytalloc_get_ptr(obj);
	PyObject *py_logname;
	if (object->in.logname == NULL) {
		Py_RETURN_NONE;
	}
	py_logname = pytalloc_reference_ex(lsa_String_Type, object->in.logname, object->in.logname);
	return py_logname;
}

static int py_eventlog_OpenEventLogW_in_set_logname(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_OpenEventLogW *object = (struct eventlog_OpenEventLogW *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.logname));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.logname");
		return -1;
	}
	object->in.logname = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->in.logname);
	if (object->in.logname == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	PY_CHECK_TYPE(lsa_String_Type, value, return -1;);
	if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	object->in.logname = (struct lsa_String *)pytalloc_get_ptr(value);
	return 0;
}

static PyObject *py_eventlog_OpenEventLogW_in_get_servername(PyObject *obj, void *closure)
{
	struct eventlog_OpenEventLogW *object = (struct eventlog_OpenEventLogW *)pytalloc_get_ptr(obj);
	PyObject *py_servername;
	if (object->in.servername == NULL) {
		Py_RETURN_NONE;
	}
	py_servername = pytalloc_reference_ex(lsa_String_Type, object->in.servername, object->in.servername);
	return py_servername;
}

static int py_eventlog_OpenEventLogW_in_set_servername(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_OpenEventLogW *object = (struct eventlog_OpenEventLogW *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.servername));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.servername");
		return -1;
	}
	object->in.servername = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->in.servername);
	if (object->in.servername == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	PY_CHECK_TYPE(lsa_String_Type, value, return -1;);
	if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	object->in.servername = (struct lsa_String *)pytalloc_get_ptr(value);
	return 0;
}

static PyObject *py_eventlog_OpenEventLogW_in_get_major_version(PyObject *obj, void *closure)
{
	struct eventlog_OpenEventLogW *object = (struct eventlog_OpenEventLogW *)pytalloc_get_ptr(obj);
	PyObject *py_major_version;
	py_major_version = PyLong_FromUnsignedLongLong((uint32_t)object->in.major_version);
	return py_major_version;
}

static int py_eventlog_OpenEventLogW_in_set_major_version(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_OpenEventLogW *object = (struct eventlog_OpenEventLogW *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.major_version");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.major_version));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->in.major_version = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_OpenEventLogW_in_get_minor_version(PyObject *obj, void *closure)
{
	struct eventlog_OpenEventLogW *object = (struct eventlog_OpenEventLogW *)pytalloc_get_ptr(obj);
	PyObject *py_minor_version;
	py_minor_version = PyLong_FromUnsignedLongLong((uint32_t)object->in.minor_version);
	return py_minor_version;
}

static int py_eventlog_OpenEventLogW_in_set_minor_version(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_OpenEventLogW *object = (struct eventlog_OpenEventLogW *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.minor_version");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.minor_version));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->in.minor_version = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_OpenEventLogW_out_get_handle(PyObject *obj, void *closure)
{
	struct eventlog_OpenEventLogW *object = (struct eventlog_OpenEventLogW *)pytalloc_get_ptr(obj);
	PyObject *py_handle;
	if (object->out.handle == NULL) {
		Py_RETURN_NONE;
	}
	py_handle = pytalloc_reference_ex(policy_handle_Type, object->out.handle, object->out.handle);
	return py_handle;
}

static int py_eventlog_OpenEventLogW_out_set_handle(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_OpenEventLogW *object = (struct eventlog_OpenEventLogW *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->out.handle));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->out.handle");
		return -1;
	}
	object->out.handle = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->out.handle);
	if (object->out.handle == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	PY_CHECK_TYPE(policy_handle_Type, value, return -1;);
	if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	object->out.handle = (struct policy_handle *)pytalloc_get_ptr(value);
	return 0;
}

static PyObject *py_eventlog_OpenEventLogW_get_result(PyObject *obj, void *closure)
{
	struct eventlog_OpenEventLogW *object = (struct eventlog_OpenEventLogW *)pytalloc_get_ptr(obj);
	PyObject *py_result;
	py_result = PyErr_FromNTSTATUS(object->out.result);
	return py_result;
}

static int py_eventlog_OpenEventLogW_set_result(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_OpenEventLogW *object = (struct eventlog_OpenEventLogW *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->out.result");
		return -1;
	}
	object->out.result = NT_STATUS(PyLong_AsLong(value));
	return 0;
}

static PyGetSetDef py_eventlog_OpenEventLogW_getsetters[] = {
	{
		.name = discard_const_p(char, "in_unknown0"),
		.get = py_eventlog_OpenEventLogW_in_get_unknown0,
		.set = py_eventlog_OpenEventLogW_in_set_unknown0,
		.doc = discard_const_p(char, "PIDL-generated element of base type eventlog_OpenUnknown0")
	},
	{
		.name = discard_const_p(char, "in_logname"),
		.get = py_eventlog_OpenEventLogW_in_get_logname,
		.set = py_eventlog_OpenEventLogW_in_set_logname,
		.doc = discard_const_p(char, "PIDL-generated element of base type lsa_String")
	},
	{
		.name = discard_const_p(char, "in_servername"),
		.get = py_eventlog_OpenEventLogW_in_get_servername,
		.set = py_eventlog_OpenEventLogW_in_set_servername,
		.doc = discard_const_p(char, "PIDL-generated element of base type lsa_String")
	},
	{
		.name = discard_const_p(char, "in_major_version"),
		.get = py_eventlog_OpenEventLogW_in_get_major_version,
		.set = py_eventlog_OpenEventLogW_in_set_major_version,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "in_minor_version"),
		.get = py_eventlog_OpenEventLogW_in_get_minor_version,
		.set = py_eventlog_OpenEventLogW_in_set_minor_version,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "out_handle"),
		.get = py_eventlog_OpenEventLogW_out_get_handle,
		.set = py_eventlog_OpenEventLogW_out_set_handle,
		.doc = discard_const_p(char, "PIDL-generated element of base type policy_handle")
	},
	{
		.name = discard_const_p(char, "result"),
		.get = py_eventlog_OpenEventLogW_get_result,
		.set = py_eventlog_OpenEventLogW_set_result,
		.doc = discard_const_p(char, "PIDL-generated element of type NTSTATUS")
	},
	{ .name = NULL }
};

static PyObject *py_eventlog_OpenEventLogW_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	PyObject *self = pytalloc_new(struct eventlog_OpenEventLogW, type);
	struct eventlog_OpenEventLogW *_self = (struct eventlog_OpenEventLogW *)pytalloc_get_ptr(self);
	TALLOC_CTX *mem_ctx = pytalloc_get_mem_ctx(self);
	_self->in.logname = talloc_zero(mem_ctx, struct lsa_String);
	_self->in.servername = talloc_zero(mem_ctx, struct lsa_String);
	_self->out.handle = talloc_zero(mem_ctx, struct policy_handle);
	return self;
}

static PyObject *py_eventlog_OpenEventLogW_ndr_opnum(PyTypeObject *type, PyObject *Py_UNUSED(ignored))
{


	return PyLong_FromLong(7);
}

static PyObject *py_eventlog_OpenEventLogW_ndr_pack(PyObject *py_obj, int ndr_inout_flags, uint32_t ndr_push_flags)
{
	const struct ndr_interface_call *call = NULL;
	struct eventlog_OpenEventLogW *object = (struct eventlog_OpenEventLogW *)pytalloc_get_ptr(py_obj);
	PyObject *ret = NULL;
	struct ndr_push *push = NULL;
	DATA_BLOB blob;
	enum ndr_err_code err;

	if (ndr_table_eventlog.num_calls < 8) {
		PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_eventlog_OpenEventLogW_ndr_pack");
		return NULL;
	}
	call = &ndr_table_eventlog.calls[7];

	push = ndr_push_init_ctx(pytalloc_get_mem_ctx(py_obj));
	if (push == NULL) {
		PyErr_SetNdrError(NDR_ERR_ALLOC);
		return NULL;
	}

	push->flags |= ndr_push_flags;

	err = call->ndr_push(push, ndr_inout_flags, object);
	if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
		TALLOC_FREE(push);
		PyErr_SetNdrError(err);
		return NULL;
	}
	blob = ndr_push_blob(push);
	ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
	TALLOC_FREE(push);
	return ret;
}

static PyObject *py_eventlog_OpenEventLogW_ndr_pack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	const char * const kwnames[] = { "bigendian", "ndr64", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_push_flags = 0;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_in__",
		discard_const_p(char *, kwnames),
		&bigendian_obj,
		&ndr64_obj)) {
		return NULL;
	}

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_NDR64;
	}

	return py_eventlog_OpenEventLogW_ndr_pack(py_obj, NDR_IN, ndr_push_flags);
}

static PyObject *py_eventlog_OpenEventLogW_ndr_pack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	const char * const kwnames[] = { "bigendian", "ndr64", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_push_flags = 0;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_out__",
		discard_const_p(char *, kwnames),
		&bigendian_obj,
		&ndr64_obj)) {
		return NULL;
	}

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_NDR64;
	}

	return py_eventlog_OpenEventLogW_ndr_pack(py_obj, NDR_OUT, ndr_push_flags);
}

static PyObject *py_eventlog_OpenEventLogW_ndr_unpack(PyObject *py_obj, const DATA_BLOB *blob, int ndr_inout_flags, uint32_t ndr_pull_flags, bool allow_remaining)
{
	const struct ndr_interface_call *call = NULL;
	struct eventlog_OpenEventLogW *object = (struct eventlog_OpenEventLogW *)pytalloc_get_ptr(py_obj);
	struct ndr_pull *pull = NULL;
	enum ndr_err_code err;

	if (ndr_table_eventlog.num_calls < 8) {
		PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_eventlog_OpenEventLogW_ndr_unpack");
		return NULL;
	}
	call = &ndr_table_eventlog.calls[7];

	pull = ndr_pull_init_blob(blob, object);
	if (pull == NULL) {
		PyErr_SetNdrError(NDR_ERR_ALLOC);
		return NULL;
	}

	pull->flags |= ndr_pull_flags;

	err = call->ndr_pull(pull, ndr_inout_flags, object);
	if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
		TALLOC_FREE(pull);
		PyErr_SetNdrError(err);
		return NULL;
	}
	if (!allow_remaining) {
		uint32_t highest_ofs;

		if (pull->offset > pull->relative_highest_offset) {
			highest_ofs = pull->offset;
		} else {
			highest_ofs = pull->relative_highest_offset;
		}
		if (highest_ofs < pull->data_size) {
			err = ndr_pull_error(pull, NDR_ERR_UNREAD_BYTES,
				"not all bytes consumed ofs[%u] size[%u]",
				highest_ofs, pull->data_size);
			TALLOC_FREE(pull);
			PyErr_SetNdrError(err);
			return NULL;
		}
	}

	TALLOC_FREE(pull);
	Py_RETURN_NONE;
}

static PyObject *py_eventlog_OpenEventLogW_ndr_unpack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	DATA_BLOB blob;
	Py_ssize_t blob_length = 0;
	const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
	PyObject *allow_remaining_obj = NULL;
	bool allow_remaining = false;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_in__",
		discard_const_p(char *, kwnames),
		&blob.data, &blob_length,
		&bigendian_obj,
		&ndr64_obj,
		&allow_remaining_obj)) {
		return NULL;
	}
	blob.length = blob_length;

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_NDR64;
	}

	if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
		allow_remaining = true;
	}

	return py_eventlog_OpenEventLogW_ndr_unpack(py_obj, &blob, NDR_IN, ndr_pull_flags, allow_remaining);
}

static PyObject *py_eventlog_OpenEventLogW_ndr_unpack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	DATA_BLOB blob;
	Py_ssize_t blob_length = 0;
	const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
	PyObject *allow_remaining_obj = NULL;
	bool allow_remaining = false;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_out__",
		discard_const_p(char *, kwnames),
		&blob.data, &blob_length,
		&bigendian_obj,
		&ndr64_obj,
		&allow_remaining_obj)) {
		return NULL;
	}
	blob.length = blob_length;

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_NDR64;
	}

	if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
		allow_remaining = true;
	}

	return py_eventlog_OpenEventLogW_ndr_unpack(py_obj, &blob, NDR_OUT, ndr_pull_flags, allow_remaining);
}

static PyObject *py_eventlog_OpenEventLogW_ndr_print(PyObject *py_obj, const char *name, int ndr_inout_flags)
{
	const struct ndr_interface_call *call = NULL;
	struct eventlog_OpenEventLogW *object = (struct eventlog_OpenEventLogW *)pytalloc_get_ptr(py_obj);
	PyObject *ret;
	char *retstr;

	if (ndr_table_eventlog.num_calls < 8) {
		PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_eventlog_OpenEventLogW_ndr_print");
		return NULL;
	}
	call = &ndr_table_eventlog.calls[7];

	retstr = ndr_print_function_string(pytalloc_get_mem_ctx(py_obj), call->ndr_print, name, ndr_inout_flags, object);
	ret = PyUnicode_FromString(retstr);
	TALLOC_FREE(retstr);

	return ret;
}

static PyObject *py_eventlog_OpenEventLogW_ndr_print_in(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
{
	return py_eventlog_OpenEventLogW_ndr_print(py_obj, "eventlog_OpenEventLogW_in", NDR_IN);
}

static PyObject *py_eventlog_OpenEventLogW_ndr_print_out(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
{
	return py_eventlog_OpenEventLogW_ndr_print(py_obj, "eventlog_OpenEventLogW_out", NDR_OUT);
}

static PyMethodDef py_eventlog_OpenEventLogW_methods[] = {
	{ "opnum", (PyCFunction)py_eventlog_OpenEventLogW_ndr_opnum, METH_NOARGS|METH_CLASS,
		"eventlog.OpenEventLogW.opnum() -> 7 (0x07) " },
	{ "__ndr_pack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_OpenEventLogW_ndr_pack_in), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_pack_in(object, bigendian=False, ndr64=False) -> blob\nNDR pack input" },
	{ "__ndr_pack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_OpenEventLogW_ndr_pack_out), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_pack_out(object, bigendian=False, ndr64=False) -> blob\nNDR pack output" },
	{ "__ndr_unpack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_OpenEventLogW_ndr_unpack_in), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_unpack_in(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack input" },
	{ "__ndr_unpack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_OpenEventLogW_ndr_unpack_out), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_unpack_out(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack output" },
	{ "__ndr_print_in__", (PyCFunction)py_eventlog_OpenEventLogW_ndr_print_in, METH_NOARGS, "S.ndr_print_in(object) -> None\nNDR print input" },
	{ "__ndr_print_out__", (PyCFunction)py_eventlog_OpenEventLogW_ndr_print_out, METH_NOARGS, "S.ndr_print_out(object) -> None\nNDR print output" },
	{ NULL, NULL, 0, NULL }
};


static PyTypeObject eventlog_OpenEventLogW_Type = {
	PyVarObject_HEAD_INIT(NULL, 0)
	.tp_name = "eventlog.OpenEventLogW",
	.tp_getset = py_eventlog_OpenEventLogW_getsetters,
	.tp_methods = py_eventlog_OpenEventLogW_methods,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_new = py_eventlog_OpenEventLogW_new,
};

static bool pack_py_eventlog_OpenEventLogW_args_in(PyObject *args, PyObject *kwargs, struct eventlog_OpenEventLogW *r)
{
	PyObject *py_unknown0;
	PyObject *py_logname;
	PyObject *py_servername;
	PyObject *py_major_version;
	PyObject *py_minor_version;
	const char *kwnames[] = {
		"unknown0", "logname", "servername", "major_version", "minor_version", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:eventlog_OpenEventLogW", discard_const_p(char *, kwnames), &py_unknown0, &py_logname, &py_servername, &py_major_version, &py_minor_version)) {
		return false;
	}

	if (py_unknown0 == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.unknown0");
		return false;
	}
	if (py_unknown0 == Py_None) {
		r->in.unknown0 = NULL;
	} else {
		r->in.unknown0 = NULL;
		PY_CHECK_TYPE(&eventlog_OpenUnknown0_Type, py_unknown0, return false;);
		if (talloc_reference(r, pytalloc_get_mem_ctx(py_unknown0)) == NULL) {
			PyErr_NoMemory();
			return false;
		}
		r->in.unknown0 = (struct eventlog_OpenUnknown0 *)pytalloc_get_ptr(py_unknown0);
	}
	if (py_logname == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.logname");
		return false;
	}
	r->in.logname = talloc_ptrtype(r, r->in.logname);
	if (r->in.logname == NULL) {
		PyErr_NoMemory();
		return false;
	}
	PY_CHECK_TYPE(lsa_String_Type, py_logname, return false;);
	if (talloc_reference(r, pytalloc_get_mem_ctx(py_logname)) == NULL) {
		PyErr_NoMemory();
		return false;
	}
	r->in.logname = (struct lsa_String *)pytalloc_get_ptr(py_logname);
	if (py_servername == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.servername");
		return false;
	}
	r->in.servername = talloc_ptrtype(r, r->in.servername);
	if (r->in.servername == NULL) {
		PyErr_NoMemory();
		return false;
	}
	PY_CHECK_TYPE(lsa_String_Type, py_servername, return false;);
	if (talloc_reference(r, pytalloc_get_mem_ctx(py_servername)) == NULL) {
		PyErr_NoMemory();
		return false;
	}
	r->in.servername = (struct lsa_String *)pytalloc_get_ptr(py_servername);
	if (py_major_version == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.major_version");
		return false;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.major_version));
		if (PyLong_Check(py_major_version)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(py_major_version);
			if (PyErr_Occurred() != NULL) {
				return false;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return false;
			}
			r->in.major_version = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return false;
		}
	}
	if (py_minor_version == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.minor_version");
		return false;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.minor_version));
		if (PyLong_Check(py_minor_version)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(py_minor_version);
			if (PyErr_Occurred() != NULL) {
				return false;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return false;
			}
			r->in.minor_version = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return false;
		}
	}
	return true;
}

static PyObject *unpack_py_eventlog_OpenEventLogW_args_out(struct eventlog_OpenEventLogW *r)
{
	PyObject *result;
	PyObject *py_handle;
	py_handle = pytalloc_reference_ex(policy_handle_Type, r->out.handle, r->out.handle);
	result = py_handle;
	if (NT_STATUS_IS_ERR(r->out.result)) {
		PyErr_SetNTSTATUS(r->out.result);
		return NULL;
	}

	return result;
}


static PyObject *py_eventlog_RegisterEventSourceW_in_get_unknown0(PyObject *obj, void *closure)
{
	struct eventlog_RegisterEventSourceW *object = (struct eventlog_RegisterEventSourceW *)pytalloc_get_ptr(obj);
	PyObject *py_unknown0;
	if (object->in.unknown0 == NULL) {
		Py_RETURN_NONE;
	}
	if (object->in.unknown0 == NULL) {
		py_unknown0 = Py_None;
		Py_INCREF(py_unknown0);
	} else {
		py_unknown0 = pytalloc_reference_ex(&eventlog_OpenUnknown0_Type, object->in.unknown0, object->in.unknown0);
	}
	return py_unknown0;
}

static int py_eventlog_RegisterEventSourceW_in_set_unknown0(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_RegisterEventSourceW *object = (struct eventlog_RegisterEventSourceW *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.unknown0));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.unknown0");
		return -1;
	}
	if (value == Py_None) {
		object->in.unknown0 = NULL;
	} else {
		object->in.unknown0 = NULL;
		PY_CHECK_TYPE(&eventlog_OpenUnknown0_Type, value, return -1;);
		if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
			PyErr_NoMemory();
			return -1;
		}
		object->in.unknown0 = (struct eventlog_OpenUnknown0 *)pytalloc_get_ptr(value);
	}
	return 0;
}

static PyObject *py_eventlog_RegisterEventSourceW_in_get_module_name(PyObject *obj, void *closure)
{
	struct eventlog_RegisterEventSourceW *object = (struct eventlog_RegisterEventSourceW *)pytalloc_get_ptr(obj);
	PyObject *py_module_name;
	if (object->in.module_name == NULL) {
		Py_RETURN_NONE;
	}
	py_module_name = pytalloc_reference_ex(lsa_String_Type, object->in.module_name, object->in.module_name);
	return py_module_name;
}

static int py_eventlog_RegisterEventSourceW_in_set_module_name(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_RegisterEventSourceW *object = (struct eventlog_RegisterEventSourceW *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.module_name));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.module_name");
		return -1;
	}
	object->in.module_name = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->in.module_name);
	if (object->in.module_name == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	PY_CHECK_TYPE(lsa_String_Type, value, return -1;);
	if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	object->in.module_name = (struct lsa_String *)pytalloc_get_ptr(value);
	return 0;
}

static PyObject *py_eventlog_RegisterEventSourceW_in_get_reg_module_name(PyObject *obj, void *closure)
{
	struct eventlog_RegisterEventSourceW *object = (struct eventlog_RegisterEventSourceW *)pytalloc_get_ptr(obj);
	PyObject *py_reg_module_name;
	if (object->in.reg_module_name == NULL) {
		Py_RETURN_NONE;
	}
	py_reg_module_name = pytalloc_reference_ex(lsa_String_Type, object->in.reg_module_name, object->in.reg_module_name);
	return py_reg_module_name;
}

static int py_eventlog_RegisterEventSourceW_in_set_reg_module_name(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_RegisterEventSourceW *object = (struct eventlog_RegisterEventSourceW *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.reg_module_name));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.reg_module_name");
		return -1;
	}
	object->in.reg_module_name = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->in.reg_module_name);
	if (object->in.reg_module_name == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	PY_CHECK_TYPE(lsa_String_Type, value, return -1;);
	if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	object->in.reg_module_name = (struct lsa_String *)pytalloc_get_ptr(value);
	return 0;
}

static PyObject *py_eventlog_RegisterEventSourceW_in_get_major_version(PyObject *obj, void *closure)
{
	struct eventlog_RegisterEventSourceW *object = (struct eventlog_RegisterEventSourceW *)pytalloc_get_ptr(obj);
	PyObject *py_major_version;
	py_major_version = PyLong_FromUnsignedLongLong((uint32_t)object->in.major_version);
	return py_major_version;
}

static int py_eventlog_RegisterEventSourceW_in_set_major_version(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_RegisterEventSourceW *object = (struct eventlog_RegisterEventSourceW *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.major_version");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.major_version));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->in.major_version = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_RegisterEventSourceW_in_get_minor_version(PyObject *obj, void *closure)
{
	struct eventlog_RegisterEventSourceW *object = (struct eventlog_RegisterEventSourceW *)pytalloc_get_ptr(obj);
	PyObject *py_minor_version;
	py_minor_version = PyLong_FromUnsignedLongLong((uint32_t)object->in.minor_version);
	return py_minor_version;
}

static int py_eventlog_RegisterEventSourceW_in_set_minor_version(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_RegisterEventSourceW *object = (struct eventlog_RegisterEventSourceW *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.minor_version");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.minor_version));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->in.minor_version = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_RegisterEventSourceW_out_get_log_handle(PyObject *obj, void *closure)
{
	struct eventlog_RegisterEventSourceW *object = (struct eventlog_RegisterEventSourceW *)pytalloc_get_ptr(obj);
	PyObject *py_log_handle;
	if (object->out.log_handle == NULL) {
		Py_RETURN_NONE;
	}
	py_log_handle = pytalloc_reference_ex(policy_handle_Type, object->out.log_handle, object->out.log_handle);
	return py_log_handle;
}

static int py_eventlog_RegisterEventSourceW_out_set_log_handle(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_RegisterEventSourceW *object = (struct eventlog_RegisterEventSourceW *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->out.log_handle));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->out.log_handle");
		return -1;
	}
	object->out.log_handle = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->out.log_handle);
	if (object->out.log_handle == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	PY_CHECK_TYPE(policy_handle_Type, value, return -1;);
	if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	object->out.log_handle = (struct policy_handle *)pytalloc_get_ptr(value);
	return 0;
}

static PyObject *py_eventlog_RegisterEventSourceW_get_result(PyObject *obj, void *closure)
{
	struct eventlog_RegisterEventSourceW *object = (struct eventlog_RegisterEventSourceW *)pytalloc_get_ptr(obj);
	PyObject *py_result;
	py_result = PyErr_FromNTSTATUS(object->out.result);
	return py_result;
}

static int py_eventlog_RegisterEventSourceW_set_result(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_RegisterEventSourceW *object = (struct eventlog_RegisterEventSourceW *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->out.result");
		return -1;
	}
	object->out.result = NT_STATUS(PyLong_AsLong(value));
	return 0;
}

static PyGetSetDef py_eventlog_RegisterEventSourceW_getsetters[] = {
	{
		.name = discard_const_p(char, "in_unknown0"),
		.get = py_eventlog_RegisterEventSourceW_in_get_unknown0,
		.set = py_eventlog_RegisterEventSourceW_in_set_unknown0,
		.doc = discard_const_p(char, "PIDL-generated element of base type eventlog_OpenUnknown0")
	},
	{
		.name = discard_const_p(char, "in_module_name"),
		.get = py_eventlog_RegisterEventSourceW_in_get_module_name,
		.set = py_eventlog_RegisterEventSourceW_in_set_module_name,
		.doc = discard_const_p(char, "PIDL-generated element of base type lsa_String")
	},
	{
		.name = discard_const_p(char, "in_reg_module_name"),
		.get = py_eventlog_RegisterEventSourceW_in_get_reg_module_name,
		.set = py_eventlog_RegisterEventSourceW_in_set_reg_module_name,
		.doc = discard_const_p(char, "PIDL-generated element of base type lsa_String")
	},
	{
		.name = discard_const_p(char, "in_major_version"),
		.get = py_eventlog_RegisterEventSourceW_in_get_major_version,
		.set = py_eventlog_RegisterEventSourceW_in_set_major_version,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "in_minor_version"),
		.get = py_eventlog_RegisterEventSourceW_in_get_minor_version,
		.set = py_eventlog_RegisterEventSourceW_in_set_minor_version,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "out_log_handle"),
		.get = py_eventlog_RegisterEventSourceW_out_get_log_handle,
		.set = py_eventlog_RegisterEventSourceW_out_set_log_handle,
		.doc = discard_const_p(char, "PIDL-generated element of base type policy_handle")
	},
	{
		.name = discard_const_p(char, "result"),
		.get = py_eventlog_RegisterEventSourceW_get_result,
		.set = py_eventlog_RegisterEventSourceW_set_result,
		.doc = discard_const_p(char, "PIDL-generated element of type NTSTATUS")
	},
	{ .name = NULL }
};

static PyObject *py_eventlog_RegisterEventSourceW_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	PyObject *self = pytalloc_new(struct eventlog_RegisterEventSourceW, type);
	struct eventlog_RegisterEventSourceW *_self = (struct eventlog_RegisterEventSourceW *)pytalloc_get_ptr(self);
	TALLOC_CTX *mem_ctx = pytalloc_get_mem_ctx(self);
	_self->in.module_name = talloc_zero(mem_ctx, struct lsa_String);
	_self->in.reg_module_name = talloc_zero(mem_ctx, struct lsa_String);
	_self->out.log_handle = talloc_zero(mem_ctx, struct policy_handle);
	return self;
}

static PyObject *py_eventlog_RegisterEventSourceW_ndr_opnum(PyTypeObject *type, PyObject *Py_UNUSED(ignored))
{


	return PyLong_FromLong(8);
}

static PyObject *py_eventlog_RegisterEventSourceW_ndr_pack(PyObject *py_obj, int ndr_inout_flags, uint32_t ndr_push_flags)
{
	const struct ndr_interface_call *call = NULL;
	struct eventlog_RegisterEventSourceW *object = (struct eventlog_RegisterEventSourceW *)pytalloc_get_ptr(py_obj);
	PyObject *ret = NULL;
	struct ndr_push *push = NULL;
	DATA_BLOB blob;
	enum ndr_err_code err;

	if (ndr_table_eventlog.num_calls < 9) {
		PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_eventlog_RegisterEventSourceW_ndr_pack");
		return NULL;
	}
	call = &ndr_table_eventlog.calls[8];

	push = ndr_push_init_ctx(pytalloc_get_mem_ctx(py_obj));
	if (push == NULL) {
		PyErr_SetNdrError(NDR_ERR_ALLOC);
		return NULL;
	}

	push->flags |= ndr_push_flags;

	err = call->ndr_push(push, ndr_inout_flags, object);
	if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
		TALLOC_FREE(push);
		PyErr_SetNdrError(err);
		return NULL;
	}
	blob = ndr_push_blob(push);
	ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
	TALLOC_FREE(push);
	return ret;
}

static PyObject *py_eventlog_RegisterEventSourceW_ndr_pack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	const char * const kwnames[] = { "bigendian", "ndr64", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_push_flags = 0;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_in__",
		discard_const_p(char *, kwnames),
		&bigendian_obj,
		&ndr64_obj)) {
		return NULL;
	}

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_NDR64;
	}

	return py_eventlog_RegisterEventSourceW_ndr_pack(py_obj, NDR_IN, ndr_push_flags);
}

static PyObject *py_eventlog_RegisterEventSourceW_ndr_pack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	const char * const kwnames[] = { "bigendian", "ndr64", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_push_flags = 0;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_out__",
		discard_const_p(char *, kwnames),
		&bigendian_obj,
		&ndr64_obj)) {
		return NULL;
	}

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_NDR64;
	}

	return py_eventlog_RegisterEventSourceW_ndr_pack(py_obj, NDR_OUT, ndr_push_flags);
}

static PyObject *py_eventlog_RegisterEventSourceW_ndr_unpack(PyObject *py_obj, const DATA_BLOB *blob, int ndr_inout_flags, uint32_t ndr_pull_flags, bool allow_remaining)
{
	const struct ndr_interface_call *call = NULL;
	struct eventlog_RegisterEventSourceW *object = (struct eventlog_RegisterEventSourceW *)pytalloc_get_ptr(py_obj);
	struct ndr_pull *pull = NULL;
	enum ndr_err_code err;

	if (ndr_table_eventlog.num_calls < 9) {
		PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_eventlog_RegisterEventSourceW_ndr_unpack");
		return NULL;
	}
	call = &ndr_table_eventlog.calls[8];

	pull = ndr_pull_init_blob(blob, object);
	if (pull == NULL) {
		PyErr_SetNdrError(NDR_ERR_ALLOC);
		return NULL;
	}

	pull->flags |= ndr_pull_flags;

	err = call->ndr_pull(pull, ndr_inout_flags, object);
	if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
		TALLOC_FREE(pull);
		PyErr_SetNdrError(err);
		return NULL;
	}
	if (!allow_remaining) {
		uint32_t highest_ofs;

		if (pull->offset > pull->relative_highest_offset) {
			highest_ofs = pull->offset;
		} else {
			highest_ofs = pull->relative_highest_offset;
		}
		if (highest_ofs < pull->data_size) {
			err = ndr_pull_error(pull, NDR_ERR_UNREAD_BYTES,
				"not all bytes consumed ofs[%u] size[%u]",
				highest_ofs, pull->data_size);
			TALLOC_FREE(pull);
			PyErr_SetNdrError(err);
			return NULL;
		}
	}

	TALLOC_FREE(pull);
	Py_RETURN_NONE;
}

static PyObject *py_eventlog_RegisterEventSourceW_ndr_unpack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	DATA_BLOB blob;
	Py_ssize_t blob_length = 0;
	const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
	PyObject *allow_remaining_obj = NULL;
	bool allow_remaining = false;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_in__",
		discard_const_p(char *, kwnames),
		&blob.data, &blob_length,
		&bigendian_obj,
		&ndr64_obj,
		&allow_remaining_obj)) {
		return NULL;
	}
	blob.length = blob_length;

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_NDR64;
	}

	if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
		allow_remaining = true;
	}

	return py_eventlog_RegisterEventSourceW_ndr_unpack(py_obj, &blob, NDR_IN, ndr_pull_flags, allow_remaining);
}

static PyObject *py_eventlog_RegisterEventSourceW_ndr_unpack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	DATA_BLOB blob;
	Py_ssize_t blob_length = 0;
	const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
	PyObject *allow_remaining_obj = NULL;
	bool allow_remaining = false;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_out__",
		discard_const_p(char *, kwnames),
		&blob.data, &blob_length,
		&bigendian_obj,
		&ndr64_obj,
		&allow_remaining_obj)) {
		return NULL;
	}
	blob.length = blob_length;

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_NDR64;
	}

	if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
		allow_remaining = true;
	}

	return py_eventlog_RegisterEventSourceW_ndr_unpack(py_obj, &blob, NDR_OUT, ndr_pull_flags, allow_remaining);
}

static PyObject *py_eventlog_RegisterEventSourceW_ndr_print(PyObject *py_obj, const char *name, int ndr_inout_flags)
{
	const struct ndr_interface_call *call = NULL;
	struct eventlog_RegisterEventSourceW *object = (struct eventlog_RegisterEventSourceW *)pytalloc_get_ptr(py_obj);
	PyObject *ret;
	char *retstr;

	if (ndr_table_eventlog.num_calls < 9) {
		PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_eventlog_RegisterEventSourceW_ndr_print");
		return NULL;
	}
	call = &ndr_table_eventlog.calls[8];

	retstr = ndr_print_function_string(pytalloc_get_mem_ctx(py_obj), call->ndr_print, name, ndr_inout_flags, object);
	ret = PyUnicode_FromString(retstr);
	TALLOC_FREE(retstr);

	return ret;
}

static PyObject *py_eventlog_RegisterEventSourceW_ndr_print_in(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
{
	return py_eventlog_RegisterEventSourceW_ndr_print(py_obj, "eventlog_RegisterEventSourceW_in", NDR_IN);
}

static PyObject *py_eventlog_RegisterEventSourceW_ndr_print_out(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
{
	return py_eventlog_RegisterEventSourceW_ndr_print(py_obj, "eventlog_RegisterEventSourceW_out", NDR_OUT);
}

static PyMethodDef py_eventlog_RegisterEventSourceW_methods[] = {
	{ "opnum", (PyCFunction)py_eventlog_RegisterEventSourceW_ndr_opnum, METH_NOARGS|METH_CLASS,
		"eventlog.RegisterEventSourceW.opnum() -> 8 (0x08) " },
	{ "__ndr_pack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_RegisterEventSourceW_ndr_pack_in), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_pack_in(object, bigendian=False, ndr64=False) -> blob\nNDR pack input" },
	{ "__ndr_pack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_RegisterEventSourceW_ndr_pack_out), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_pack_out(object, bigendian=False, ndr64=False) -> blob\nNDR pack output" },
	{ "__ndr_unpack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_RegisterEventSourceW_ndr_unpack_in), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_unpack_in(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack input" },
	{ "__ndr_unpack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_RegisterEventSourceW_ndr_unpack_out), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_unpack_out(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack output" },
	{ "__ndr_print_in__", (PyCFunction)py_eventlog_RegisterEventSourceW_ndr_print_in, METH_NOARGS, "S.ndr_print_in(object) -> None\nNDR print input" },
	{ "__ndr_print_out__", (PyCFunction)py_eventlog_RegisterEventSourceW_ndr_print_out, METH_NOARGS, "S.ndr_print_out(object) -> None\nNDR print output" },
	{ NULL, NULL, 0, NULL }
};


static PyTypeObject eventlog_RegisterEventSourceW_Type = {
	PyVarObject_HEAD_INIT(NULL, 0)
	.tp_name = "eventlog.RegisterEventSourceW",
	.tp_getset = py_eventlog_RegisterEventSourceW_getsetters,
	.tp_methods = py_eventlog_RegisterEventSourceW_methods,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_new = py_eventlog_RegisterEventSourceW_new,
};

static bool pack_py_eventlog_RegisterEventSourceW_args_in(PyObject *args, PyObject *kwargs, struct eventlog_RegisterEventSourceW *r)
{
	PyObject *py_unknown0;
	PyObject *py_module_name;
	PyObject *py_reg_module_name;
	PyObject *py_major_version;
	PyObject *py_minor_version;
	const char *kwnames[] = {
		"unknown0", "module_name", "reg_module_name", "major_version", "minor_version", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:eventlog_RegisterEventSourceW", discard_const_p(char *, kwnames), &py_unknown0, &py_module_name, &py_reg_module_name, &py_major_version, &py_minor_version)) {
		return false;
	}

	if (py_unknown0 == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.unknown0");
		return false;
	}
	if (py_unknown0 == Py_None) {
		r->in.unknown0 = NULL;
	} else {
		r->in.unknown0 = NULL;
		PY_CHECK_TYPE(&eventlog_OpenUnknown0_Type, py_unknown0, return false;);
		if (talloc_reference(r, pytalloc_get_mem_ctx(py_unknown0)) == NULL) {
			PyErr_NoMemory();
			return false;
		}
		r->in.unknown0 = (struct eventlog_OpenUnknown0 *)pytalloc_get_ptr(py_unknown0);
	}
	if (py_module_name == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.module_name");
		return false;
	}
	r->in.module_name = talloc_ptrtype(r, r->in.module_name);
	if (r->in.module_name == NULL) {
		PyErr_NoMemory();
		return false;
	}
	PY_CHECK_TYPE(lsa_String_Type, py_module_name, return false;);
	if (talloc_reference(r, pytalloc_get_mem_ctx(py_module_name)) == NULL) {
		PyErr_NoMemory();
		return false;
	}
	r->in.module_name = (struct lsa_String *)pytalloc_get_ptr(py_module_name);
	if (py_reg_module_name == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.reg_module_name");
		return false;
	}
	r->in.reg_module_name = talloc_ptrtype(r, r->in.reg_module_name);
	if (r->in.reg_module_name == NULL) {
		PyErr_NoMemory();
		return false;
	}
	PY_CHECK_TYPE(lsa_String_Type, py_reg_module_name, return false;);
	if (talloc_reference(r, pytalloc_get_mem_ctx(py_reg_module_name)) == NULL) {
		PyErr_NoMemory();
		return false;
	}
	r->in.reg_module_name = (struct lsa_String *)pytalloc_get_ptr(py_reg_module_name);
	if (py_major_version == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.major_version");
		return false;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.major_version));
		if (PyLong_Check(py_major_version)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(py_major_version);
			if (PyErr_Occurred() != NULL) {
				return false;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return false;
			}
			r->in.major_version = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return false;
		}
	}
	if (py_minor_version == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.minor_version");
		return false;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.minor_version));
		if (PyLong_Check(py_minor_version)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(py_minor_version);
			if (PyErr_Occurred() != NULL) {
				return false;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return false;
			}
			r->in.minor_version = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return false;
		}
	}
	return true;
}

static PyObject *unpack_py_eventlog_RegisterEventSourceW_args_out(struct eventlog_RegisterEventSourceW *r)
{
	PyObject *result;
	PyObject *py_log_handle;
	py_log_handle = pytalloc_reference_ex(policy_handle_Type, r->out.log_handle, r->out.log_handle);
	result = py_log_handle;
	if (NT_STATUS_IS_ERR(r->out.result)) {
		PyErr_SetNTSTATUS(r->out.result);
		return NULL;
	}

	return result;
}


static PyObject *py_eventlog_OpenBackupEventLogW_in_get_unknown0(PyObject *obj, void *closure)
{
	struct eventlog_OpenBackupEventLogW *object = (struct eventlog_OpenBackupEventLogW *)pytalloc_get_ptr(obj);
	PyObject *py_unknown0;
	if (object->in.unknown0 == NULL) {
		Py_RETURN_NONE;
	}
	if (object->in.unknown0 == NULL) {
		py_unknown0 = Py_None;
		Py_INCREF(py_unknown0);
	} else {
		py_unknown0 = pytalloc_reference_ex(&eventlog_OpenUnknown0_Type, object->in.unknown0, object->in.unknown0);
	}
	return py_unknown0;
}

static int py_eventlog_OpenBackupEventLogW_in_set_unknown0(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_OpenBackupEventLogW *object = (struct eventlog_OpenBackupEventLogW *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.unknown0));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.unknown0");
		return -1;
	}
	if (value == Py_None) {
		object->in.unknown0 = NULL;
	} else {
		object->in.unknown0 = NULL;
		PY_CHECK_TYPE(&eventlog_OpenUnknown0_Type, value, return -1;);
		if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
			PyErr_NoMemory();
			return -1;
		}
		object->in.unknown0 = (struct eventlog_OpenUnknown0 *)pytalloc_get_ptr(value);
	}
	return 0;
}

static PyObject *py_eventlog_OpenBackupEventLogW_in_get_backup_logname(PyObject *obj, void *closure)
{
	struct eventlog_OpenBackupEventLogW *object = (struct eventlog_OpenBackupEventLogW *)pytalloc_get_ptr(obj);
	PyObject *py_backup_logname;
	if (object->in.backup_logname == NULL) {
		Py_RETURN_NONE;
	}
	py_backup_logname = pytalloc_reference_ex(lsa_String_Type, object->in.backup_logname, object->in.backup_logname);
	return py_backup_logname;
}

static int py_eventlog_OpenBackupEventLogW_in_set_backup_logname(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_OpenBackupEventLogW *object = (struct eventlog_OpenBackupEventLogW *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.backup_logname));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.backup_logname");
		return -1;
	}
	object->in.backup_logname = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->in.backup_logname);
	if (object->in.backup_logname == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	PY_CHECK_TYPE(lsa_String_Type, value, return -1;);
	if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	object->in.backup_logname = (struct lsa_String *)pytalloc_get_ptr(value);
	return 0;
}

static PyObject *py_eventlog_OpenBackupEventLogW_in_get_major_version(PyObject *obj, void *closure)
{
	struct eventlog_OpenBackupEventLogW *object = (struct eventlog_OpenBackupEventLogW *)pytalloc_get_ptr(obj);
	PyObject *py_major_version;
	py_major_version = PyLong_FromUnsignedLongLong((uint32_t)object->in.major_version);
	return py_major_version;
}

static int py_eventlog_OpenBackupEventLogW_in_set_major_version(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_OpenBackupEventLogW *object = (struct eventlog_OpenBackupEventLogW *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.major_version");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.major_version));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->in.major_version = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_OpenBackupEventLogW_in_get_minor_version(PyObject *obj, void *closure)
{
	struct eventlog_OpenBackupEventLogW *object = (struct eventlog_OpenBackupEventLogW *)pytalloc_get_ptr(obj);
	PyObject *py_minor_version;
	py_minor_version = PyLong_FromUnsignedLongLong((uint32_t)object->in.minor_version);
	return py_minor_version;
}

static int py_eventlog_OpenBackupEventLogW_in_set_minor_version(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_OpenBackupEventLogW *object = (struct eventlog_OpenBackupEventLogW *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.minor_version");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.minor_version));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->in.minor_version = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_OpenBackupEventLogW_out_get_handle(PyObject *obj, void *closure)
{
	struct eventlog_OpenBackupEventLogW *object = (struct eventlog_OpenBackupEventLogW *)pytalloc_get_ptr(obj);
	PyObject *py_handle;
	if (object->out.handle == NULL) {
		Py_RETURN_NONE;
	}
	py_handle = pytalloc_reference_ex(policy_handle_Type, object->out.handle, object->out.handle);
	return py_handle;
}

static int py_eventlog_OpenBackupEventLogW_out_set_handle(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_OpenBackupEventLogW *object = (struct eventlog_OpenBackupEventLogW *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->out.handle));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->out.handle");
		return -1;
	}
	object->out.handle = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->out.handle);
	if (object->out.handle == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	PY_CHECK_TYPE(policy_handle_Type, value, return -1;);
	if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	object->out.handle = (struct policy_handle *)pytalloc_get_ptr(value);
	return 0;
}

static PyObject *py_eventlog_OpenBackupEventLogW_get_result(PyObject *obj, void *closure)
{
	struct eventlog_OpenBackupEventLogW *object = (struct eventlog_OpenBackupEventLogW *)pytalloc_get_ptr(obj);
	PyObject *py_result;
	py_result = PyErr_FromNTSTATUS(object->out.result);
	return py_result;
}

static int py_eventlog_OpenBackupEventLogW_set_result(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_OpenBackupEventLogW *object = (struct eventlog_OpenBackupEventLogW *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->out.result");
		return -1;
	}
	object->out.result = NT_STATUS(PyLong_AsLong(value));
	return 0;
}

static PyGetSetDef py_eventlog_OpenBackupEventLogW_getsetters[] = {
	{
		.name = discard_const_p(char, "in_unknown0"),
		.get = py_eventlog_OpenBackupEventLogW_in_get_unknown0,
		.set = py_eventlog_OpenBackupEventLogW_in_set_unknown0,
		.doc = discard_const_p(char, "PIDL-generated element of base type eventlog_OpenUnknown0")
	},
	{
		.name = discard_const_p(char, "in_backup_logname"),
		.get = py_eventlog_OpenBackupEventLogW_in_get_backup_logname,
		.set = py_eventlog_OpenBackupEventLogW_in_set_backup_logname,
		.doc = discard_const_p(char, "PIDL-generated element of base type lsa_String")
	},
	{
		.name = discard_const_p(char, "in_major_version"),
		.get = py_eventlog_OpenBackupEventLogW_in_get_major_version,
		.set = py_eventlog_OpenBackupEventLogW_in_set_major_version,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "in_minor_version"),
		.get = py_eventlog_OpenBackupEventLogW_in_get_minor_version,
		.set = py_eventlog_OpenBackupEventLogW_in_set_minor_version,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "out_handle"),
		.get = py_eventlog_OpenBackupEventLogW_out_get_handle,
		.set = py_eventlog_OpenBackupEventLogW_out_set_handle,
		.doc = discard_const_p(char, "PIDL-generated element of base type policy_handle")
	},
	{
		.name = discard_const_p(char, "result"),
		.get = py_eventlog_OpenBackupEventLogW_get_result,
		.set = py_eventlog_OpenBackupEventLogW_set_result,
		.doc = discard_const_p(char, "PIDL-generated element of type NTSTATUS")
	},
	{ .name = NULL }
};

static PyObject *py_eventlog_OpenBackupEventLogW_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	PyObject *self = pytalloc_new(struct eventlog_OpenBackupEventLogW, type);
	struct eventlog_OpenBackupEventLogW *_self = (struct eventlog_OpenBackupEventLogW *)pytalloc_get_ptr(self);
	TALLOC_CTX *mem_ctx = pytalloc_get_mem_ctx(self);
	_self->in.backup_logname = talloc_zero(mem_ctx, struct lsa_String);
	_self->out.handle = talloc_zero(mem_ctx, struct policy_handle);
	return self;
}

static PyObject *py_eventlog_OpenBackupEventLogW_ndr_opnum(PyTypeObject *type, PyObject *Py_UNUSED(ignored))
{


	return PyLong_FromLong(9);
}

static PyObject *py_eventlog_OpenBackupEventLogW_ndr_pack(PyObject *py_obj, int ndr_inout_flags, uint32_t ndr_push_flags)
{
	const struct ndr_interface_call *call = NULL;
	struct eventlog_OpenBackupEventLogW *object = (struct eventlog_OpenBackupEventLogW *)pytalloc_get_ptr(py_obj);
	PyObject *ret = NULL;
	struct ndr_push *push = NULL;
	DATA_BLOB blob;
	enum ndr_err_code err;

	if (ndr_table_eventlog.num_calls < 10) {
		PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_eventlog_OpenBackupEventLogW_ndr_pack");
		return NULL;
	}
	call = &ndr_table_eventlog.calls[9];

	push = ndr_push_init_ctx(pytalloc_get_mem_ctx(py_obj));
	if (push == NULL) {
		PyErr_SetNdrError(NDR_ERR_ALLOC);
		return NULL;
	}

	push->flags |= ndr_push_flags;

	err = call->ndr_push(push, ndr_inout_flags, object);
	if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
		TALLOC_FREE(push);
		PyErr_SetNdrError(err);
		return NULL;
	}
	blob = ndr_push_blob(push);
	ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
	TALLOC_FREE(push);
	return ret;
}

static PyObject *py_eventlog_OpenBackupEventLogW_ndr_pack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	const char * const kwnames[] = { "bigendian", "ndr64", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_push_flags = 0;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_in__",
		discard_const_p(char *, kwnames),
		&bigendian_obj,
		&ndr64_obj)) {
		return NULL;
	}

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_NDR64;
	}

	return py_eventlog_OpenBackupEventLogW_ndr_pack(py_obj, NDR_IN, ndr_push_flags);
}

static PyObject *py_eventlog_OpenBackupEventLogW_ndr_pack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	const char * const kwnames[] = { "bigendian", "ndr64", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_push_flags = 0;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_out__",
		discard_const_p(char *, kwnames),
		&bigendian_obj,
		&ndr64_obj)) {
		return NULL;
	}

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_NDR64;
	}

	return py_eventlog_OpenBackupEventLogW_ndr_pack(py_obj, NDR_OUT, ndr_push_flags);
}

static PyObject *py_eventlog_OpenBackupEventLogW_ndr_unpack(PyObject *py_obj, const DATA_BLOB *blob, int ndr_inout_flags, uint32_t ndr_pull_flags, bool allow_remaining)
{
	const struct ndr_interface_call *call = NULL;
	struct eventlog_OpenBackupEventLogW *object = (struct eventlog_OpenBackupEventLogW *)pytalloc_get_ptr(py_obj);
	struct ndr_pull *pull = NULL;
	enum ndr_err_code err;

	if (ndr_table_eventlog.num_calls < 10) {
		PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_eventlog_OpenBackupEventLogW_ndr_unpack");
		return NULL;
	}
	call = &ndr_table_eventlog.calls[9];

	pull = ndr_pull_init_blob(blob, object);
	if (pull == NULL) {
		PyErr_SetNdrError(NDR_ERR_ALLOC);
		return NULL;
	}

	pull->flags |= ndr_pull_flags;

	err = call->ndr_pull(pull, ndr_inout_flags, object);
	if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
		TALLOC_FREE(pull);
		PyErr_SetNdrError(err);
		return NULL;
	}
	if (!allow_remaining) {
		uint32_t highest_ofs;

		if (pull->offset > pull->relative_highest_offset) {
			highest_ofs = pull->offset;
		} else {
			highest_ofs = pull->relative_highest_offset;
		}
		if (highest_ofs < pull->data_size) {
			err = ndr_pull_error(pull, NDR_ERR_UNREAD_BYTES,
				"not all bytes consumed ofs[%u] size[%u]",
				highest_ofs, pull->data_size);
			TALLOC_FREE(pull);
			PyErr_SetNdrError(err);
			return NULL;
		}
	}

	TALLOC_FREE(pull);
	Py_RETURN_NONE;
}

static PyObject *py_eventlog_OpenBackupEventLogW_ndr_unpack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	DATA_BLOB blob;
	Py_ssize_t blob_length = 0;
	const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
	PyObject *allow_remaining_obj = NULL;
	bool allow_remaining = false;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_in__",
		discard_const_p(char *, kwnames),
		&blob.data, &blob_length,
		&bigendian_obj,
		&ndr64_obj,
		&allow_remaining_obj)) {
		return NULL;
	}
	blob.length = blob_length;

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_NDR64;
	}

	if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
		allow_remaining = true;
	}

	return py_eventlog_OpenBackupEventLogW_ndr_unpack(py_obj, &blob, NDR_IN, ndr_pull_flags, allow_remaining);
}

static PyObject *py_eventlog_OpenBackupEventLogW_ndr_unpack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	DATA_BLOB blob;
	Py_ssize_t blob_length = 0;
	const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
	PyObject *allow_remaining_obj = NULL;
	bool allow_remaining = false;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_out__",
		discard_const_p(char *, kwnames),
		&blob.data, &blob_length,
		&bigendian_obj,
		&ndr64_obj,
		&allow_remaining_obj)) {
		return NULL;
	}
	blob.length = blob_length;

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_NDR64;
	}

	if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
		allow_remaining = true;
	}

	return py_eventlog_OpenBackupEventLogW_ndr_unpack(py_obj, &blob, NDR_OUT, ndr_pull_flags, allow_remaining);
}

static PyObject *py_eventlog_OpenBackupEventLogW_ndr_print(PyObject *py_obj, const char *name, int ndr_inout_flags)
{
	const struct ndr_interface_call *call = NULL;
	struct eventlog_OpenBackupEventLogW *object = (struct eventlog_OpenBackupEventLogW *)pytalloc_get_ptr(py_obj);
	PyObject *ret;
	char *retstr;

	if (ndr_table_eventlog.num_calls < 10) {
		PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_eventlog_OpenBackupEventLogW_ndr_print");
		return NULL;
	}
	call = &ndr_table_eventlog.calls[9];

	retstr = ndr_print_function_string(pytalloc_get_mem_ctx(py_obj), call->ndr_print, name, ndr_inout_flags, object);
	ret = PyUnicode_FromString(retstr);
	TALLOC_FREE(retstr);

	return ret;
}

static PyObject *py_eventlog_OpenBackupEventLogW_ndr_print_in(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
{
	return py_eventlog_OpenBackupEventLogW_ndr_print(py_obj, "eventlog_OpenBackupEventLogW_in", NDR_IN);
}

static PyObject *py_eventlog_OpenBackupEventLogW_ndr_print_out(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
{
	return py_eventlog_OpenBackupEventLogW_ndr_print(py_obj, "eventlog_OpenBackupEventLogW_out", NDR_OUT);
}

static PyMethodDef py_eventlog_OpenBackupEventLogW_methods[] = {
	{ "opnum", (PyCFunction)py_eventlog_OpenBackupEventLogW_ndr_opnum, METH_NOARGS|METH_CLASS,
		"eventlog.OpenBackupEventLogW.opnum() -> 9 (0x09) " },
	{ "__ndr_pack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_OpenBackupEventLogW_ndr_pack_in), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_pack_in(object, bigendian=False, ndr64=False) -> blob\nNDR pack input" },
	{ "__ndr_pack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_OpenBackupEventLogW_ndr_pack_out), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_pack_out(object, bigendian=False, ndr64=False) -> blob\nNDR pack output" },
	{ "__ndr_unpack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_OpenBackupEventLogW_ndr_unpack_in), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_unpack_in(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack input" },
	{ "__ndr_unpack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_OpenBackupEventLogW_ndr_unpack_out), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_unpack_out(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack output" },
	{ "__ndr_print_in__", (PyCFunction)py_eventlog_OpenBackupEventLogW_ndr_print_in, METH_NOARGS, "S.ndr_print_in(object) -> None\nNDR print input" },
	{ "__ndr_print_out__", (PyCFunction)py_eventlog_OpenBackupEventLogW_ndr_print_out, METH_NOARGS, "S.ndr_print_out(object) -> None\nNDR print output" },
	{ NULL, NULL, 0, NULL }
};


static PyTypeObject eventlog_OpenBackupEventLogW_Type = {
	PyVarObject_HEAD_INIT(NULL, 0)
	.tp_name = "eventlog.OpenBackupEventLogW",
	.tp_getset = py_eventlog_OpenBackupEventLogW_getsetters,
	.tp_methods = py_eventlog_OpenBackupEventLogW_methods,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_new = py_eventlog_OpenBackupEventLogW_new,
};

static bool pack_py_eventlog_OpenBackupEventLogW_args_in(PyObject *args, PyObject *kwargs, struct eventlog_OpenBackupEventLogW *r)
{
	PyObject *py_unknown0;
	PyObject *py_backup_logname;
	PyObject *py_major_version;
	PyObject *py_minor_version;
	const char *kwnames[] = {
		"unknown0", "backup_logname", "major_version", "minor_version", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:eventlog_OpenBackupEventLogW", discard_const_p(char *, kwnames), &py_unknown0, &py_backup_logname, &py_major_version, &py_minor_version)) {
		return false;
	}

	if (py_unknown0 == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.unknown0");
		return false;
	}
	if (py_unknown0 == Py_None) {
		r->in.unknown0 = NULL;
	} else {
		r->in.unknown0 = NULL;
		PY_CHECK_TYPE(&eventlog_OpenUnknown0_Type, py_unknown0, return false;);
		if (talloc_reference(r, pytalloc_get_mem_ctx(py_unknown0)) == NULL) {
			PyErr_NoMemory();
			return false;
		}
		r->in.unknown0 = (struct eventlog_OpenUnknown0 *)pytalloc_get_ptr(py_unknown0);
	}
	if (py_backup_logname == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.backup_logname");
		return false;
	}
	r->in.backup_logname = talloc_ptrtype(r, r->in.backup_logname);
	if (r->in.backup_logname == NULL) {
		PyErr_NoMemory();
		return false;
	}
	PY_CHECK_TYPE(lsa_String_Type, py_backup_logname, return false;);
	if (talloc_reference(r, pytalloc_get_mem_ctx(py_backup_logname)) == NULL) {
		PyErr_NoMemory();
		return false;
	}
	r->in.backup_logname = (struct lsa_String *)pytalloc_get_ptr(py_backup_logname);
	if (py_major_version == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.major_version");
		return false;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.major_version));
		if (PyLong_Check(py_major_version)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(py_major_version);
			if (PyErr_Occurred() != NULL) {
				return false;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return false;
			}
			r->in.major_version = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return false;
		}
	}
	if (py_minor_version == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.minor_version");
		return false;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.minor_version));
		if (PyLong_Check(py_minor_version)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(py_minor_version);
			if (PyErr_Occurred() != NULL) {
				return false;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return false;
			}
			r->in.minor_version = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return false;
		}
	}
	return true;
}

static PyObject *unpack_py_eventlog_OpenBackupEventLogW_args_out(struct eventlog_OpenBackupEventLogW *r)
{
	PyObject *result;
	PyObject *py_handle;
	py_handle = pytalloc_reference_ex(policy_handle_Type, r->out.handle, r->out.handle);
	result = py_handle;
	if (NT_STATUS_IS_ERR(r->out.result)) {
		PyErr_SetNTSTATUS(r->out.result);
		return NULL;
	}

	return result;
}


static PyObject *py_eventlog_ReadEventLogW_in_get_handle(PyObject *obj, void *closure)
{
	struct eventlog_ReadEventLogW *object = (struct eventlog_ReadEventLogW *)pytalloc_get_ptr(obj);
	PyObject *py_handle;
	if (object->in.handle == NULL) {
		Py_RETURN_NONE;
	}
	py_handle = pytalloc_reference_ex(policy_handle_Type, object->in.handle, object->in.handle);
	return py_handle;
}

static int py_eventlog_ReadEventLogW_in_set_handle(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_ReadEventLogW *object = (struct eventlog_ReadEventLogW *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.handle));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.handle");
		return -1;
	}
	object->in.handle = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->in.handle);
	if (object->in.handle == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	PY_CHECK_TYPE(policy_handle_Type, value, return -1;);
	if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	object->in.handle = (struct policy_handle *)pytalloc_get_ptr(value);
	return 0;
}

static PyObject *py_eventlog_ReadEventLogW_in_get_flags(PyObject *obj, void *closure)
{
	struct eventlog_ReadEventLogW *object = (struct eventlog_ReadEventLogW *)pytalloc_get_ptr(obj);
	PyObject *py_flags;
	py_flags = PyLong_FromUnsignedLongLong((uint32_t)object->in.flags);
	return py_flags;
}

static int py_eventlog_ReadEventLogW_in_set_flags(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_ReadEventLogW *object = (struct eventlog_ReadEventLogW *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.flags");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.flags));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->in.flags = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_ReadEventLogW_in_get_offset(PyObject *obj, void *closure)
{
	struct eventlog_ReadEventLogW *object = (struct eventlog_ReadEventLogW *)pytalloc_get_ptr(obj);
	PyObject *py_offset;
	py_offset = PyLong_FromUnsignedLongLong((uint32_t)object->in.offset);
	return py_offset;
}

static int py_eventlog_ReadEventLogW_in_set_offset(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_ReadEventLogW *object = (struct eventlog_ReadEventLogW *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.offset");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.offset));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->in.offset = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_ReadEventLogW_in_get_number_of_bytes(PyObject *obj, void *closure)
{
	struct eventlog_ReadEventLogW *object = (struct eventlog_ReadEventLogW *)pytalloc_get_ptr(obj);
	PyObject *py_number_of_bytes;
	py_number_of_bytes = PyLong_FromUnsignedLongLong((uint32_t)object->in.number_of_bytes);
	return py_number_of_bytes;
}

static int py_eventlog_ReadEventLogW_in_set_number_of_bytes(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_ReadEventLogW *object = (struct eventlog_ReadEventLogW *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.number_of_bytes");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.number_of_bytes));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->in.number_of_bytes = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_ReadEventLogW_out_get_data(PyObject *obj, void *closure)
{
	struct eventlog_ReadEventLogW *object = (struct eventlog_ReadEventLogW *)pytalloc_get_ptr(obj);
	PyObject *py_data;
	if (object->out.data == NULL) {
		Py_RETURN_NONE;
	}
	py_data = PyList_New(object->in.number_of_bytes);
	if (py_data == NULL) {
		return NULL;
	}
	{
		int data_cntr_1;
		for (data_cntr_1 = 0; data_cntr_1 < (object->in.number_of_bytes); data_cntr_1++) {
			PyObject *py_data_1;
			py_data_1 = PyLong_FromLong((uint16_t)object->out.data[data_cntr_1]);
			PyList_SetItem(py_data, data_cntr_1, py_data_1);
		}
	}
	return py_data;
}

static int py_eventlog_ReadEventLogW_out_set_data(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_ReadEventLogW *object = (struct eventlog_ReadEventLogW *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->out.data));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->out.data");
		return -1;
	}
	object->out.data = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->out.data);
	if (object->out.data == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	PY_CHECK_TYPE(&PyList_Type, value, return -1;);
	{
		int data_cntr_1;
		object->out.data = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->out.data, PyList_GET_SIZE(value));
		if (!object->out.data) { return -1;; }
		talloc_set_name_const(object->out.data, "ARRAY: object->out.data");
		for (data_cntr_1 = 0; data_cntr_1 < PyList_GET_SIZE(value); data_cntr_1++) {
			if (PyList_GET_ITEM(value, data_cntr_1) == NULL) {
				PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->out.data[data_cntr_1]");
				return -1;
			}
			{
				const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->out.data[data_cntr_1]));
				if (PyLong_Check(PyList_GET_ITEM(value, data_cntr_1))) {
					unsigned long long test_var;
					test_var = PyLong_AsUnsignedLongLong(PyList_GET_ITEM(value, data_cntr_1));
					if (PyErr_Occurred() != NULL) {
						return -1;
					}
					if (test_var > uint_max) {
						PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
						  PyLong_Type.tp_name, uint_max, test_var);
						return -1;
					}
					object->out.data[data_cntr_1] = test_var;
				} else {
					PyErr_Format(PyExc_TypeError, "Expected type %s",\
					  PyLong_Type.tp_name);
					return -1;
				}
			}
		}
	}
	return 0;
}

static PyObject *py_eventlog_ReadEventLogW_out_get_sent_size(PyObject *obj, void *closure)
{
	struct eventlog_ReadEventLogW *object = (struct eventlog_ReadEventLogW *)pytalloc_get_ptr(obj);
	PyObject *py_sent_size;
	if (object->out.sent_size == NULL) {
		Py_RETURN_NONE;
	}
	py_sent_size = PyLong_FromUnsignedLongLong((uint32_t)*object->out.sent_size);
	return py_sent_size;
}

static int py_eventlog_ReadEventLogW_out_set_sent_size(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_ReadEventLogW *object = (struct eventlog_ReadEventLogW *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->out.sent_size));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->out.sent_size");
		return -1;
	}
	object->out.sent_size = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->out.sent_size);
	if (object->out.sent_size == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(*object->out.sent_size));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			*object->out.sent_size = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_ReadEventLogW_out_get_real_size(PyObject *obj, void *closure)
{
	struct eventlog_ReadEventLogW *object = (struct eventlog_ReadEventLogW *)pytalloc_get_ptr(obj);
	PyObject *py_real_size;
	if (object->out.real_size == NULL) {
		Py_RETURN_NONE;
	}
	py_real_size = PyLong_FromUnsignedLongLong((uint32_t)*object->out.real_size);
	return py_real_size;
}

static int py_eventlog_ReadEventLogW_out_set_real_size(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_ReadEventLogW *object = (struct eventlog_ReadEventLogW *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->out.real_size));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->out.real_size");
		return -1;
	}
	object->out.real_size = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->out.real_size);
	if (object->out.real_size == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(*object->out.real_size));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			*object->out.real_size = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_ReadEventLogW_get_result(PyObject *obj, void *closure)
{
	struct eventlog_ReadEventLogW *object = (struct eventlog_ReadEventLogW *)pytalloc_get_ptr(obj);
	PyObject *py_result;
	py_result = PyErr_FromNTSTATUS(object->out.result);
	return py_result;
}

static int py_eventlog_ReadEventLogW_set_result(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_ReadEventLogW *object = (struct eventlog_ReadEventLogW *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->out.result");
		return -1;
	}
	object->out.result = NT_STATUS(PyLong_AsLong(value));
	return 0;
}

static PyGetSetDef py_eventlog_ReadEventLogW_getsetters[] = {
	{
		.name = discard_const_p(char, "in_handle"),
		.get = py_eventlog_ReadEventLogW_in_get_handle,
		.set = py_eventlog_ReadEventLogW_in_set_handle,
		.doc = discard_const_p(char, "PIDL-generated element of base type policy_handle")
	},
	{
		.name = discard_const_p(char, "in_flags"),
		.get = py_eventlog_ReadEventLogW_in_get_flags,
		.set = py_eventlog_ReadEventLogW_in_set_flags,
		.doc = discard_const_p(char, "PIDL-generated element of base type eventlogReadFlags")
	},
	{
		.name = discard_const_p(char, "in_offset"),
		.get = py_eventlog_ReadEventLogW_in_get_offset,
		.set = py_eventlog_ReadEventLogW_in_set_offset,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "in_number_of_bytes"),
		.get = py_eventlog_ReadEventLogW_in_get_number_of_bytes,
		.set = py_eventlog_ReadEventLogW_in_set_number_of_bytes,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "out_data"),
		.get = py_eventlog_ReadEventLogW_out_get_data,
		.set = py_eventlog_ReadEventLogW_out_set_data,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint8")
	},
	{
		.name = discard_const_p(char, "out_sent_size"),
		.get = py_eventlog_ReadEventLogW_out_get_sent_size,
		.set = py_eventlog_ReadEventLogW_out_set_sent_size,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "out_real_size"),
		.get = py_eventlog_ReadEventLogW_out_get_real_size,
		.set = py_eventlog_ReadEventLogW_out_set_real_size,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "result"),
		.get = py_eventlog_ReadEventLogW_get_result,
		.set = py_eventlog_ReadEventLogW_set_result,
		.doc = discard_const_p(char, "PIDL-generated element of type NTSTATUS")
	},
	{ .name = NULL }
};

static PyObject *py_eventlog_ReadEventLogW_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	PyObject *self = pytalloc_new(struct eventlog_ReadEventLogW, type);
	struct eventlog_ReadEventLogW *_self = (struct eventlog_ReadEventLogW *)pytalloc_get_ptr(self);
	TALLOC_CTX *mem_ctx = pytalloc_get_mem_ctx(self);
	_self->in.handle = talloc_zero(mem_ctx, struct policy_handle);
	_self->out.data = talloc_zero(mem_ctx, uint8_t);
	_self->out.sent_size = talloc_zero(mem_ctx, uint32_t);
	_self->out.real_size = talloc_zero(mem_ctx, uint32_t);
	return self;
}

static PyObject *py_eventlog_ReadEventLogW_ndr_opnum(PyTypeObject *type, PyObject *Py_UNUSED(ignored))
{


	return PyLong_FromLong(10);
}

static PyObject *py_eventlog_ReadEventLogW_ndr_pack(PyObject *py_obj, int ndr_inout_flags, uint32_t ndr_push_flags)
{
	const struct ndr_interface_call *call = NULL;
	struct eventlog_ReadEventLogW *object = (struct eventlog_ReadEventLogW *)pytalloc_get_ptr(py_obj);
	PyObject *ret = NULL;
	struct ndr_push *push = NULL;
	DATA_BLOB blob;
	enum ndr_err_code err;

	if (ndr_table_eventlog.num_calls < 11) {
		PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_eventlog_ReadEventLogW_ndr_pack");
		return NULL;
	}
	call = &ndr_table_eventlog.calls[10];

	push = ndr_push_init_ctx(pytalloc_get_mem_ctx(py_obj));
	if (push == NULL) {
		PyErr_SetNdrError(NDR_ERR_ALLOC);
		return NULL;
	}

	push->flags |= ndr_push_flags;

	err = call->ndr_push(push, ndr_inout_flags, object);
	if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
		TALLOC_FREE(push);
		PyErr_SetNdrError(err);
		return NULL;
	}
	blob = ndr_push_blob(push);
	ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
	TALLOC_FREE(push);
	return ret;
}

static PyObject *py_eventlog_ReadEventLogW_ndr_pack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	const char * const kwnames[] = { "bigendian", "ndr64", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_push_flags = 0;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_in__",
		discard_const_p(char *, kwnames),
		&bigendian_obj,
		&ndr64_obj)) {
		return NULL;
	}

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_NDR64;
	}

	return py_eventlog_ReadEventLogW_ndr_pack(py_obj, NDR_IN, ndr_push_flags);
}

static PyObject *py_eventlog_ReadEventLogW_ndr_pack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	const char * const kwnames[] = { "bigendian", "ndr64", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_push_flags = 0;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_out__",
		discard_const_p(char *, kwnames),
		&bigendian_obj,
		&ndr64_obj)) {
		return NULL;
	}

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_NDR64;
	}

	return py_eventlog_ReadEventLogW_ndr_pack(py_obj, NDR_OUT, ndr_push_flags);
}

static PyObject *py_eventlog_ReadEventLogW_ndr_unpack(PyObject *py_obj, const DATA_BLOB *blob, int ndr_inout_flags, uint32_t ndr_pull_flags, bool allow_remaining)
{
	const struct ndr_interface_call *call = NULL;
	struct eventlog_ReadEventLogW *object = (struct eventlog_ReadEventLogW *)pytalloc_get_ptr(py_obj);
	struct ndr_pull *pull = NULL;
	enum ndr_err_code err;

	if (ndr_table_eventlog.num_calls < 11) {
		PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_eventlog_ReadEventLogW_ndr_unpack");
		return NULL;
	}
	call = &ndr_table_eventlog.calls[10];

	pull = ndr_pull_init_blob(blob, object);
	if (pull == NULL) {
		PyErr_SetNdrError(NDR_ERR_ALLOC);
		return NULL;
	}

	pull->flags |= ndr_pull_flags;

	err = call->ndr_pull(pull, ndr_inout_flags, object);
	if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
		TALLOC_FREE(pull);
		PyErr_SetNdrError(err);
		return NULL;
	}
	if (!allow_remaining) {
		uint32_t highest_ofs;

		if (pull->offset > pull->relative_highest_offset) {
			highest_ofs = pull->offset;
		} else {
			highest_ofs = pull->relative_highest_offset;
		}
		if (highest_ofs < pull->data_size) {
			err = ndr_pull_error(pull, NDR_ERR_UNREAD_BYTES,
				"not all bytes consumed ofs[%u] size[%u]",
				highest_ofs, pull->data_size);
			TALLOC_FREE(pull);
			PyErr_SetNdrError(err);
			return NULL;
		}
	}

	TALLOC_FREE(pull);
	Py_RETURN_NONE;
}

static PyObject *py_eventlog_ReadEventLogW_ndr_unpack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	DATA_BLOB blob;
	Py_ssize_t blob_length = 0;
	const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
	PyObject *allow_remaining_obj = NULL;
	bool allow_remaining = false;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_in__",
		discard_const_p(char *, kwnames),
		&blob.data, &blob_length,
		&bigendian_obj,
		&ndr64_obj,
		&allow_remaining_obj)) {
		return NULL;
	}
	blob.length = blob_length;

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_NDR64;
	}

	if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
		allow_remaining = true;
	}

	return py_eventlog_ReadEventLogW_ndr_unpack(py_obj, &blob, NDR_IN, ndr_pull_flags, allow_remaining);
}

static PyObject *py_eventlog_ReadEventLogW_ndr_unpack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	DATA_BLOB blob;
	Py_ssize_t blob_length = 0;
	const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
	PyObject *allow_remaining_obj = NULL;
	bool allow_remaining = false;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_out__",
		discard_const_p(char *, kwnames),
		&blob.data, &blob_length,
		&bigendian_obj,
		&ndr64_obj,
		&allow_remaining_obj)) {
		return NULL;
	}
	blob.length = blob_length;

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_NDR64;
	}

	if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
		allow_remaining = true;
	}

	return py_eventlog_ReadEventLogW_ndr_unpack(py_obj, &blob, NDR_OUT, ndr_pull_flags, allow_remaining);
}

static PyObject *py_eventlog_ReadEventLogW_ndr_print(PyObject *py_obj, const char *name, int ndr_inout_flags)
{
	const struct ndr_interface_call *call = NULL;
	struct eventlog_ReadEventLogW *object = (struct eventlog_ReadEventLogW *)pytalloc_get_ptr(py_obj);
	PyObject *ret;
	char *retstr;

	if (ndr_table_eventlog.num_calls < 11) {
		PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_eventlog_ReadEventLogW_ndr_print");
		return NULL;
	}
	call = &ndr_table_eventlog.calls[10];

	retstr = ndr_print_function_string(pytalloc_get_mem_ctx(py_obj), call->ndr_print, name, ndr_inout_flags, object);
	ret = PyUnicode_FromString(retstr);
	TALLOC_FREE(retstr);

	return ret;
}

static PyObject *py_eventlog_ReadEventLogW_ndr_print_in(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
{
	return py_eventlog_ReadEventLogW_ndr_print(py_obj, "eventlog_ReadEventLogW_in", NDR_IN);
}

static PyObject *py_eventlog_ReadEventLogW_ndr_print_out(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
{
	return py_eventlog_ReadEventLogW_ndr_print(py_obj, "eventlog_ReadEventLogW_out", NDR_OUT);
}

static PyMethodDef py_eventlog_ReadEventLogW_methods[] = {
	{ "opnum", (PyCFunction)py_eventlog_ReadEventLogW_ndr_opnum, METH_NOARGS|METH_CLASS,
		"eventlog.ReadEventLogW.opnum() -> 10 (0x0a) " },
	{ "__ndr_pack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_ReadEventLogW_ndr_pack_in), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_pack_in(object, bigendian=False, ndr64=False) -> blob\nNDR pack input" },
	{ "__ndr_pack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_ReadEventLogW_ndr_pack_out), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_pack_out(object, bigendian=False, ndr64=False) -> blob\nNDR pack output" },
	{ "__ndr_unpack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_ReadEventLogW_ndr_unpack_in), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_unpack_in(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack input" },
	{ "__ndr_unpack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_ReadEventLogW_ndr_unpack_out), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_unpack_out(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack output" },
	{ "__ndr_print_in__", (PyCFunction)py_eventlog_ReadEventLogW_ndr_print_in, METH_NOARGS, "S.ndr_print_in(object) -> None\nNDR print input" },
	{ "__ndr_print_out__", (PyCFunction)py_eventlog_ReadEventLogW_ndr_print_out, METH_NOARGS, "S.ndr_print_out(object) -> None\nNDR print output" },
	{ NULL, NULL, 0, NULL }
};


static PyTypeObject eventlog_ReadEventLogW_Type = {
	PyVarObject_HEAD_INIT(NULL, 0)
	.tp_name = "eventlog.ReadEventLogW",
	.tp_getset = py_eventlog_ReadEventLogW_getsetters,
	.tp_methods = py_eventlog_ReadEventLogW_methods,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_new = py_eventlog_ReadEventLogW_new,
};

static bool pack_py_eventlog_ReadEventLogW_args_in(PyObject *args, PyObject *kwargs, struct eventlog_ReadEventLogW *r)
{
	PyObject *py_handle;
	PyObject *py_flags;
	PyObject *py_offset;
	PyObject *py_number_of_bytes;
	const char *kwnames[] = {
		"handle", "flags", "offset", "number_of_bytes", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:eventlog_ReadEventLogW", discard_const_p(char *, kwnames), &py_handle, &py_flags, &py_offset, &py_number_of_bytes)) {
		return false;
	}

	if (py_handle == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.handle");
		return false;
	}
	r->in.handle = talloc_ptrtype(r, r->in.handle);
	if (r->in.handle == NULL) {
		PyErr_NoMemory();
		return false;
	}
	PY_CHECK_TYPE(policy_handle_Type, py_handle, return false;);
	if (talloc_reference(r, pytalloc_get_mem_ctx(py_handle)) == NULL) {
		PyErr_NoMemory();
		return false;
	}
	r->in.handle = (struct policy_handle *)pytalloc_get_ptr(py_handle);
	if (py_flags == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.flags");
		return false;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.flags));
		if (PyLong_Check(py_flags)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(py_flags);
			if (PyErr_Occurred() != NULL) {
				return false;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return false;
			}
			r->in.flags = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return false;
		}
	}
	if (py_offset == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.offset");
		return false;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.offset));
		if (PyLong_Check(py_offset)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(py_offset);
			if (PyErr_Occurred() != NULL) {
				return false;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return false;
			}
			r->in.offset = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return false;
		}
	}
	if (py_number_of_bytes == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.number_of_bytes");
		return false;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.number_of_bytes));
		if (PyLong_Check(py_number_of_bytes)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(py_number_of_bytes);
			if (PyErr_Occurred() != NULL) {
				return false;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return false;
			}
			r->in.number_of_bytes = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return false;
		}
	}
	return true;
}

static PyObject *unpack_py_eventlog_ReadEventLogW_args_out(struct eventlog_ReadEventLogW *r)
{
	PyObject *result;
	PyObject *py_data;
	PyObject *py_sent_size;
	PyObject *py_real_size;
	result = PyTuple_New(3);
	py_data = PyList_New(r->in.number_of_bytes);
	if (py_data == NULL) {
		return NULL;
	}
	{
		int data_cntr_1;
		for (data_cntr_1 = 0; data_cntr_1 < (r->in.number_of_bytes); data_cntr_1++) {
			PyObject *py_data_1;
			py_data_1 = PyLong_FromLong((uint16_t)r->out.data[data_cntr_1]);
			PyList_SetItem(py_data, data_cntr_1, py_data_1);
		}
	}
	PyTuple_SetItem(result, 0, py_data);
	py_sent_size = PyLong_FromUnsignedLongLong((uint32_t)*r->out.sent_size);
	PyTuple_SetItem(result, 1, py_sent_size);
	py_real_size = PyLong_FromUnsignedLongLong((uint32_t)*r->out.real_size);
	PyTuple_SetItem(result, 2, py_real_size);
	if (NT_STATUS_IS_ERR(r->out.result)) {
		PyErr_SetNTSTATUS(r->out.result);
		return NULL;
	}

	return result;
}


static PyObject *py_eventlog_ReportEventW_in_get_handle(PyObject *obj, void *closure)
{
	struct eventlog_ReportEventW *object = (struct eventlog_ReportEventW *)pytalloc_get_ptr(obj);
	PyObject *py_handle;
	if (object->in.handle == NULL) {
		Py_RETURN_NONE;
	}
	py_handle = pytalloc_reference_ex(policy_handle_Type, object->in.handle, object->in.handle);
	return py_handle;
}

static int py_eventlog_ReportEventW_in_set_handle(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_ReportEventW *object = (struct eventlog_ReportEventW *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.handle));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.handle");
		return -1;
	}
	object->in.handle = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->in.handle);
	if (object->in.handle == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	PY_CHECK_TYPE(policy_handle_Type, value, return -1;);
	if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	object->in.handle = (struct policy_handle *)pytalloc_get_ptr(value);
	return 0;
}

static PyObject *py_eventlog_ReportEventW_in_get_timestamp(PyObject *obj, void *closure)
{
	struct eventlog_ReportEventW *object = (struct eventlog_ReportEventW *)pytalloc_get_ptr(obj);
	PyObject *py_timestamp;
	py_timestamp = PyLong_FromLong(object->in.timestamp);
	return py_timestamp;
}

static int py_eventlog_ReportEventW_in_set_timestamp(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_ReportEventW *object = (struct eventlog_ReportEventW *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.timestamp");
		return -1;
	}
	{
		const long long int_max = ndr_sizeof2intmax(sizeof(object->in.timestamp));
		const long long int_min = -int_max - 1;
		if (PyLong_Check(value)) {
			long long test_var;
			test_var = PyLong_AsLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var < int_min || test_var > int_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range %lld - %lld, got %lld",\
				  PyLong_Type.tp_name, int_min, int_max, test_var);
				return -1;
			}
			object->in.timestamp = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_ReportEventW_in_get_event_type(PyObject *obj, void *closure)
{
	struct eventlog_ReportEventW *object = (struct eventlog_ReportEventW *)pytalloc_get_ptr(obj);
	PyObject *py_event_type;
	py_event_type = PyLong_FromLong((uint16_t)object->in.event_type);
	return py_event_type;
}

static int py_eventlog_ReportEventW_in_set_event_type(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_ReportEventW *object = (struct eventlog_ReportEventW *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.event_type");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.event_type));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->in.event_type = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_ReportEventW_in_get_event_category(PyObject *obj, void *closure)
{
	struct eventlog_ReportEventW *object = (struct eventlog_ReportEventW *)pytalloc_get_ptr(obj);
	PyObject *py_event_category;
	py_event_category = PyLong_FromLong((uint16_t)object->in.event_category);
	return py_event_category;
}

static int py_eventlog_ReportEventW_in_set_event_category(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_ReportEventW *object = (struct eventlog_ReportEventW *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.event_category");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.event_category));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->in.event_category = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_ReportEventW_in_get_event_id(PyObject *obj, void *closure)
{
	struct eventlog_ReportEventW *object = (struct eventlog_ReportEventW *)pytalloc_get_ptr(obj);
	PyObject *py_event_id;
	py_event_id = PyLong_FromUnsignedLongLong((uint32_t)object->in.event_id);
	return py_event_id;
}

static int py_eventlog_ReportEventW_in_set_event_id(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_ReportEventW *object = (struct eventlog_ReportEventW *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.event_id");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.event_id));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->in.event_id = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_ReportEventW_in_get_num_of_strings(PyObject *obj, void *closure)
{
	struct eventlog_ReportEventW *object = (struct eventlog_ReportEventW *)pytalloc_get_ptr(obj);
	PyObject *py_num_of_strings;
	py_num_of_strings = PyLong_FromLong((uint16_t)object->in.num_of_strings);
	return py_num_of_strings;
}

static int py_eventlog_ReportEventW_in_set_num_of_strings(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_ReportEventW *object = (struct eventlog_ReportEventW *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.num_of_strings");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.num_of_strings));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->in.num_of_strings = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_ReportEventW_in_get_data_size(PyObject *obj, void *closure)
{
	struct eventlog_ReportEventW *object = (struct eventlog_ReportEventW *)pytalloc_get_ptr(obj);
	PyObject *py_data_size;
	py_data_size = PyLong_FromUnsignedLongLong((uint32_t)object->in.data_size);
	return py_data_size;
}

static int py_eventlog_ReportEventW_in_set_data_size(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_ReportEventW *object = (struct eventlog_ReportEventW *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.data_size");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.data_size));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->in.data_size = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_ReportEventW_in_get_servername(PyObject *obj, void *closure)
{
	struct eventlog_ReportEventW *object = (struct eventlog_ReportEventW *)pytalloc_get_ptr(obj);
	PyObject *py_servername;
	if (object->in.servername == NULL) {
		Py_RETURN_NONE;
	}
	py_servername = pytalloc_reference_ex(lsa_String_Type, object->in.servername, object->in.servername);
	return py_servername;
}

static int py_eventlog_ReportEventW_in_set_servername(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_ReportEventW *object = (struct eventlog_ReportEventW *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.servername));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.servername");
		return -1;
	}
	object->in.servername = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->in.servername);
	if (object->in.servername == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	PY_CHECK_TYPE(lsa_String_Type, value, return -1;);
	if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	object->in.servername = (struct lsa_String *)pytalloc_get_ptr(value);
	return 0;
}

static PyObject *py_eventlog_ReportEventW_in_get_user_sid(PyObject *obj, void *closure)
{
	struct eventlog_ReportEventW *object = (struct eventlog_ReportEventW *)pytalloc_get_ptr(obj);
	PyObject *py_user_sid;
	if (object->in.user_sid == NULL) {
		Py_RETURN_NONE;
	}
	if (object->in.user_sid == NULL) {
		py_user_sid = Py_None;
		Py_INCREF(py_user_sid);
	} else {
		py_user_sid = pytalloc_reference_ex(dom_sid_Type, object->in.user_sid, object->in.user_sid);
	}
	return py_user_sid;
}

static int py_eventlog_ReportEventW_in_set_user_sid(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_ReportEventW *object = (struct eventlog_ReportEventW *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.user_sid));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.user_sid");
		return -1;
	}
	if (value == Py_None) {
		object->in.user_sid = NULL;
	} else {
		object->in.user_sid = NULL;
		PY_CHECK_TYPE(dom_sid_Type, value, return -1;);
		if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
			PyErr_NoMemory();
			return -1;
		}
		object->in.user_sid = (struct dom_sid *)pytalloc_get_ptr(value);
	}
	return 0;
}

static PyObject *py_eventlog_ReportEventW_in_get_strings(PyObject *obj, void *closure)
{
	struct eventlog_ReportEventW *object = (struct eventlog_ReportEventW *)pytalloc_get_ptr(obj);
	PyObject *py_strings;
	if (object->in.strings == NULL) {
		Py_RETURN_NONE;
	}
	if (object->in.strings == NULL) {
		py_strings = Py_None;
		Py_INCREF(py_strings);
	} else {
		py_strings = PyList_New(object->in.num_of_strings);
		if (py_strings == NULL) {
			return NULL;
		}
		{
			int strings_cntr_1;
			for (strings_cntr_1 = 0; strings_cntr_1 < (object->in.num_of_strings); strings_cntr_1++) {
				PyObject *py_strings_1;
				if (object->in.strings[strings_cntr_1] == NULL) {
					py_strings_1 = Py_None;
					Py_INCREF(py_strings_1);
				} else {
					py_strings_1 = pytalloc_reference_ex(lsa_String_Type, object->in.strings[strings_cntr_1], object->in.strings[strings_cntr_1]);
				}
				PyList_SetItem(py_strings, strings_cntr_1, py_strings_1);
			}
		}
	}
	return py_strings;
}

static int py_eventlog_ReportEventW_in_set_strings(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_ReportEventW *object = (struct eventlog_ReportEventW *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.strings));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.strings");
		return -1;
	}
	if (value == Py_None) {
		object->in.strings = NULL;
	} else {
		object->in.strings = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int strings_cntr_1;
			object->in.strings = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->in.strings, PyList_GET_SIZE(value));
			if (!object->in.strings) { return -1;; }
			talloc_set_name_const(object->in.strings, "ARRAY: object->in.strings");
			for (strings_cntr_1 = 0; strings_cntr_1 < PyList_GET_SIZE(value); strings_cntr_1++) {
				if (PyList_GET_ITEM(value, strings_cntr_1) == NULL) {
					PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.strings[strings_cntr_1]");
					return -1;
				}
				if (PyList_GET_ITEM(value, strings_cntr_1) == Py_None) {
					object->in.strings[strings_cntr_1] = NULL;
				} else {
					object->in.strings[strings_cntr_1] = NULL;
					PY_CHECK_TYPE(lsa_String_Type, PyList_GET_ITEM(value, strings_cntr_1), return -1;);
					if (talloc_reference(object->in.strings, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, strings_cntr_1))) == NULL) {
						PyErr_NoMemory();
						return -1;
					}
					object->in.strings[strings_cntr_1] = (struct lsa_String *)pytalloc_get_ptr(PyList_GET_ITEM(value, strings_cntr_1));
				}
			}
		}
	}
	return 0;
}

static PyObject *py_eventlog_ReportEventW_in_get_data(PyObject *obj, void *closure)
{
	struct eventlog_ReportEventW *object = (struct eventlog_ReportEventW *)pytalloc_get_ptr(obj);
	PyObject *py_data;
	if (object->in.data == NULL) {
		Py_RETURN_NONE;
	}
	if (object->in.data == NULL) {
		py_data = Py_None;
		Py_INCREF(py_data);
	} else {
		py_data = PyList_New(object->in.data_size);
		if (py_data == NULL) {
			return NULL;
		}
		{
			int data_cntr_1;
			for (data_cntr_1 = 0; data_cntr_1 < (object->in.data_size); data_cntr_1++) {
				PyObject *py_data_1;
				py_data_1 = PyLong_FromLong((uint16_t)object->in.data[data_cntr_1]);
				PyList_SetItem(py_data, data_cntr_1, py_data_1);
			}
		}
	}
	return py_data;
}

static int py_eventlog_ReportEventW_in_set_data(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_ReportEventW *object = (struct eventlog_ReportEventW *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.data));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.data");
		return -1;
	}
	if (value == Py_None) {
		object->in.data = NULL;
	} else {
		object->in.data = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int data_cntr_1;
			object->in.data = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->in.data, PyList_GET_SIZE(value));
			if (!object->in.data) { return -1;; }
			talloc_set_name_const(object->in.data, "ARRAY: object->in.data");
			for (data_cntr_1 = 0; data_cntr_1 < PyList_GET_SIZE(value); data_cntr_1++) {
				if (PyList_GET_ITEM(value, data_cntr_1) == NULL) {
					PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.data[data_cntr_1]");
					return -1;
				}
				{
					const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.data[data_cntr_1]));
					if (PyLong_Check(PyList_GET_ITEM(value, data_cntr_1))) {
						unsigned long long test_var;
						test_var = PyLong_AsUnsignedLongLong(PyList_GET_ITEM(value, data_cntr_1));
						if (PyErr_Occurred() != NULL) {
							return -1;
						}
						if (test_var > uint_max) {
							PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
							  PyLong_Type.tp_name, uint_max, test_var);
							return -1;
						}
						object->in.data[data_cntr_1] = test_var;
					} else {
						PyErr_Format(PyExc_TypeError, "Expected type %s",\
						  PyLong_Type.tp_name);
						return -1;
					}
				}
			}
		}
	}
	return 0;
}

static PyObject *py_eventlog_ReportEventW_in_get_flags(PyObject *obj, void *closure)
{
	struct eventlog_ReportEventW *object = (struct eventlog_ReportEventW *)pytalloc_get_ptr(obj);
	PyObject *py_flags;
	py_flags = PyLong_FromLong((uint16_t)object->in.flags);
	return py_flags;
}

static int py_eventlog_ReportEventW_in_set_flags(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_ReportEventW *object = (struct eventlog_ReportEventW *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.flags");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.flags));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->in.flags = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_ReportEventW_in_get_record_number(PyObject *obj, void *closure)
{
	struct eventlog_ReportEventW *object = (struct eventlog_ReportEventW *)pytalloc_get_ptr(obj);
	PyObject *py_record_number;
	if (object->in.record_number == NULL) {
		Py_RETURN_NONE;
	}
	if (object->in.record_number == NULL) {
		py_record_number = Py_None;
		Py_INCREF(py_record_number);
	} else {
		py_record_number = PyLong_FromUnsignedLongLong((uint32_t)*object->in.record_number);
	}
	return py_record_number;
}

static int py_eventlog_ReportEventW_in_set_record_number(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_ReportEventW *object = (struct eventlog_ReportEventW *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.record_number));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.record_number");
		return -1;
	}
	if (value == Py_None) {
		object->in.record_number = NULL;
	} else {
		object->in.record_number = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->in.record_number);
		if (object->in.record_number == NULL) {
			PyErr_NoMemory();
			return -1;
		}
		{
			const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(*object->in.record_number));
			if (PyLong_Check(value)) {
				unsigned long long test_var;
				test_var = PyLong_AsUnsignedLongLong(value);
				if (PyErr_Occurred() != NULL) {
					return -1;
				}
				if (test_var > uint_max) {
					PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
					  PyLong_Type.tp_name, uint_max, test_var);
					return -1;
				}
				*object->in.record_number = test_var;
			} else {
				PyErr_Format(PyExc_TypeError, "Expected type %s",\
				  PyLong_Type.tp_name);
				return -1;
			}
		}
	}
	return 0;
}

static PyObject *py_eventlog_ReportEventW_out_get_record_number(PyObject *obj, void *closure)
{
	struct eventlog_ReportEventW *object = (struct eventlog_ReportEventW *)pytalloc_get_ptr(obj);
	PyObject *py_record_number;
	if (object->out.record_number == NULL) {
		Py_RETURN_NONE;
	}
	if (object->out.record_number == NULL) {
		py_record_number = Py_None;
		Py_INCREF(py_record_number);
	} else {
		py_record_number = PyLong_FromUnsignedLongLong((uint32_t)*object->out.record_number);
	}
	return py_record_number;
}

static int py_eventlog_ReportEventW_out_set_record_number(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_ReportEventW *object = (struct eventlog_ReportEventW *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->out.record_number));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->out.record_number");
		return -1;
	}
	if (value == Py_None) {
		object->out.record_number = NULL;
	} else {
		object->out.record_number = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->out.record_number);
		if (object->out.record_number == NULL) {
			PyErr_NoMemory();
			return -1;
		}
		{
			const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(*object->out.record_number));
			if (PyLong_Check(value)) {
				unsigned long long test_var;
				test_var = PyLong_AsUnsignedLongLong(value);
				if (PyErr_Occurred() != NULL) {
					return -1;
				}
				if (test_var > uint_max) {
					PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
					  PyLong_Type.tp_name, uint_max, test_var);
					return -1;
				}
				*object->out.record_number = test_var;
			} else {
				PyErr_Format(PyExc_TypeError, "Expected type %s",\
				  PyLong_Type.tp_name);
				return -1;
			}
		}
	}
	return 0;
}

static PyObject *py_eventlog_ReportEventW_in_get_time_written(PyObject *obj, void *closure)
{
	struct eventlog_ReportEventW *object = (struct eventlog_ReportEventW *)pytalloc_get_ptr(obj);
	PyObject *py_time_written;
	if (object->in.time_written == NULL) {
		Py_RETURN_NONE;
	}
	if (object->in.time_written == NULL) {
		py_time_written = Py_None;
		Py_INCREF(py_time_written);
	} else {
		py_time_written = PyLong_FromLong(*object->in.time_written);
	}
	return py_time_written;
}

static int py_eventlog_ReportEventW_in_set_time_written(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_ReportEventW *object = (struct eventlog_ReportEventW *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.time_written));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.time_written");
		return -1;
	}
	if (value == Py_None) {
		object->in.time_written = NULL;
	} else {
		object->in.time_written = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->in.time_written);
		if (object->in.time_written == NULL) {
			PyErr_NoMemory();
			return -1;
		}
		{
			const long long int_max = ndr_sizeof2intmax(sizeof(*object->in.time_written));
			const long long int_min = -int_max - 1;
			if (PyLong_Check(value)) {
				long long test_var;
				test_var = PyLong_AsLongLong(value);
				if (PyErr_Occurred() != NULL) {
					return -1;
				}
				if (test_var < int_min || test_var > int_max) {
					PyErr_Format(PyExc_OverflowError, "Expected type %s within range %lld - %lld, got %lld",\
					  PyLong_Type.tp_name, int_min, int_max, test_var);
					return -1;
				}
				*object->in.time_written = test_var;
			} else {
				PyErr_Format(PyExc_TypeError, "Expected type %s",\
				  PyLong_Type.tp_name);
				return -1;
			}
		}
	}
	return 0;
}

static PyObject *py_eventlog_ReportEventW_out_get_time_written(PyObject *obj, void *closure)
{
	struct eventlog_ReportEventW *object = (struct eventlog_ReportEventW *)pytalloc_get_ptr(obj);
	PyObject *py_time_written;
	if (object->out.time_written == NULL) {
		Py_RETURN_NONE;
	}
	if (object->out.time_written == NULL) {
		py_time_written = Py_None;
		Py_INCREF(py_time_written);
	} else {
		py_time_written = PyLong_FromLong(*object->out.time_written);
	}
	return py_time_written;
}

static int py_eventlog_ReportEventW_out_set_time_written(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_ReportEventW *object = (struct eventlog_ReportEventW *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->out.time_written));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->out.time_written");
		return -1;
	}
	if (value == Py_None) {
		object->out.time_written = NULL;
	} else {
		object->out.time_written = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->out.time_written);
		if (object->out.time_written == NULL) {
			PyErr_NoMemory();
			return -1;
		}
		{
			const long long int_max = ndr_sizeof2intmax(sizeof(*object->out.time_written));
			const long long int_min = -int_max - 1;
			if (PyLong_Check(value)) {
				long long test_var;
				test_var = PyLong_AsLongLong(value);
				if (PyErr_Occurred() != NULL) {
					return -1;
				}
				if (test_var < int_min || test_var > int_max) {
					PyErr_Format(PyExc_OverflowError, "Expected type %s within range %lld - %lld, got %lld",\
					  PyLong_Type.tp_name, int_min, int_max, test_var);
					return -1;
				}
				*object->out.time_written = test_var;
			} else {
				PyErr_Format(PyExc_TypeError, "Expected type %s",\
				  PyLong_Type.tp_name);
				return -1;
			}
		}
	}
	return 0;
}

static PyObject *py_eventlog_ReportEventW_get_result(PyObject *obj, void *closure)
{
	struct eventlog_ReportEventW *object = (struct eventlog_ReportEventW *)pytalloc_get_ptr(obj);
	PyObject *py_result;
	py_result = PyErr_FromNTSTATUS(object->out.result);
	return py_result;
}

static int py_eventlog_ReportEventW_set_result(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_ReportEventW *object = (struct eventlog_ReportEventW *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->out.result");
		return -1;
	}
	object->out.result = NT_STATUS(PyLong_AsLong(value));
	return 0;
}

static PyGetSetDef py_eventlog_ReportEventW_getsetters[] = {
	{
		.name = discard_const_p(char, "in_handle"),
		.get = py_eventlog_ReportEventW_in_get_handle,
		.set = py_eventlog_ReportEventW_in_set_handle,
		.doc = discard_const_p(char, "PIDL-generated element of base type policy_handle")
	},
	{
		.name = discard_const_p(char, "in_timestamp"),
		.get = py_eventlog_ReportEventW_in_get_timestamp,
		.set = py_eventlog_ReportEventW_in_set_timestamp,
		.doc = discard_const_p(char, "PIDL-generated element of base type time_t")
	},
	{
		.name = discard_const_p(char, "in_event_type"),
		.get = py_eventlog_ReportEventW_in_get_event_type,
		.set = py_eventlog_ReportEventW_in_set_event_type,
		.doc = discard_const_p(char, "PIDL-generated element of base type eventlogEventTypes")
	},
	{
		.name = discard_const_p(char, "in_event_category"),
		.get = py_eventlog_ReportEventW_in_get_event_category,
		.set = py_eventlog_ReportEventW_in_set_event_category,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint16")
	},
	{
		.name = discard_const_p(char, "in_event_id"),
		.get = py_eventlog_ReportEventW_in_get_event_id,
		.set = py_eventlog_ReportEventW_in_set_event_id,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "in_num_of_strings"),
		.get = py_eventlog_ReportEventW_in_get_num_of_strings,
		.set = py_eventlog_ReportEventW_in_set_num_of_strings,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint16")
	},
	{
		.name = discard_const_p(char, "in_data_size"),
		.get = py_eventlog_ReportEventW_in_get_data_size,
		.set = py_eventlog_ReportEventW_in_set_data_size,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "in_servername"),
		.get = py_eventlog_ReportEventW_in_get_servername,
		.set = py_eventlog_ReportEventW_in_set_servername,
		.doc = discard_const_p(char, "PIDL-generated element of base type lsa_String")
	},
	{
		.name = discard_const_p(char, "in_user_sid"),
		.get = py_eventlog_ReportEventW_in_get_user_sid,
		.set = py_eventlog_ReportEventW_in_set_user_sid,
		.doc = discard_const_p(char, "PIDL-generated element of base type dom_sid")
	},
	{
		.name = discard_const_p(char, "in_strings"),
		.get = py_eventlog_ReportEventW_in_get_strings,
		.set = py_eventlog_ReportEventW_in_set_strings,
		.doc = discard_const_p(char, "PIDL-generated element of base type lsa_String")
	},
	{
		.name = discard_const_p(char, "in_data"),
		.get = py_eventlog_ReportEventW_in_get_data,
		.set = py_eventlog_ReportEventW_in_set_data,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint8")
	},
	{
		.name = discard_const_p(char, "in_flags"),
		.get = py_eventlog_ReportEventW_in_get_flags,
		.set = py_eventlog_ReportEventW_in_set_flags,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint16")
	},
	{
		.name = discard_const_p(char, "in_record_number"),
		.get = py_eventlog_ReportEventW_in_get_record_number,
		.set = py_eventlog_ReportEventW_in_set_record_number,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "out_record_number"),
		.get = py_eventlog_ReportEventW_out_get_record_number,
		.set = py_eventlog_ReportEventW_out_set_record_number,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "in_time_written"),
		.get = py_eventlog_ReportEventW_in_get_time_written,
		.set = py_eventlog_ReportEventW_in_set_time_written,
		.doc = discard_const_p(char, "PIDL-generated element of base type time_t")
	},
	{
		.name = discard_const_p(char, "out_time_written"),
		.get = py_eventlog_ReportEventW_out_get_time_written,
		.set = py_eventlog_ReportEventW_out_set_time_written,
		.doc = discard_const_p(char, "PIDL-generated element of base type time_t")
	},
	{
		.name = discard_const_p(char, "result"),
		.get = py_eventlog_ReportEventW_get_result,
		.set = py_eventlog_ReportEventW_set_result,
		.doc = discard_const_p(char, "PIDL-generated element of type NTSTATUS")
	},
	{ .name = NULL }
};

static PyObject *py_eventlog_ReportEventW_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	PyObject *self = pytalloc_new(struct eventlog_ReportEventW, type);
	struct eventlog_ReportEventW *_self = (struct eventlog_ReportEventW *)pytalloc_get_ptr(self);
	TALLOC_CTX *mem_ctx = pytalloc_get_mem_ctx(self);
	_self->in.handle = talloc_zero(mem_ctx, struct policy_handle);
	_self->in.servername = talloc_zero(mem_ctx, struct lsa_String);
	return self;
}

static PyObject *py_eventlog_ReportEventW_ndr_opnum(PyTypeObject *type, PyObject *Py_UNUSED(ignored))
{


	return PyLong_FromLong(11);
}

static PyObject *py_eventlog_ReportEventW_ndr_pack(PyObject *py_obj, int ndr_inout_flags, uint32_t ndr_push_flags)
{
	const struct ndr_interface_call *call = NULL;
	struct eventlog_ReportEventW *object = (struct eventlog_ReportEventW *)pytalloc_get_ptr(py_obj);
	PyObject *ret = NULL;
	struct ndr_push *push = NULL;
	DATA_BLOB blob;
	enum ndr_err_code err;

	if (ndr_table_eventlog.num_calls < 12) {
		PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_eventlog_ReportEventW_ndr_pack");
		return NULL;
	}
	call = &ndr_table_eventlog.calls[11];

	push = ndr_push_init_ctx(pytalloc_get_mem_ctx(py_obj));
	if (push == NULL) {
		PyErr_SetNdrError(NDR_ERR_ALLOC);
		return NULL;
	}

	push->flags |= ndr_push_flags;

	err = call->ndr_push(push, ndr_inout_flags, object);
	if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
		TALLOC_FREE(push);
		PyErr_SetNdrError(err);
		return NULL;
	}
	blob = ndr_push_blob(push);
	ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
	TALLOC_FREE(push);
	return ret;
}

static PyObject *py_eventlog_ReportEventW_ndr_pack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	const char * const kwnames[] = { "bigendian", "ndr64", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_push_flags = 0;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_in__",
		discard_const_p(char *, kwnames),
		&bigendian_obj,
		&ndr64_obj)) {
		return NULL;
	}

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_NDR64;
	}

	return py_eventlog_ReportEventW_ndr_pack(py_obj, NDR_IN, ndr_push_flags);
}

static PyObject *py_eventlog_ReportEventW_ndr_pack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	const char * const kwnames[] = { "bigendian", "ndr64", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_push_flags = 0;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_out__",
		discard_const_p(char *, kwnames),
		&bigendian_obj,
		&ndr64_obj)) {
		return NULL;
	}

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_NDR64;
	}

	return py_eventlog_ReportEventW_ndr_pack(py_obj, NDR_OUT, ndr_push_flags);
}

static PyObject *py_eventlog_ReportEventW_ndr_unpack(PyObject *py_obj, const DATA_BLOB *blob, int ndr_inout_flags, uint32_t ndr_pull_flags, bool allow_remaining)
{
	const struct ndr_interface_call *call = NULL;
	struct eventlog_ReportEventW *object = (struct eventlog_ReportEventW *)pytalloc_get_ptr(py_obj);
	struct ndr_pull *pull = NULL;
	enum ndr_err_code err;

	if (ndr_table_eventlog.num_calls < 12) {
		PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_eventlog_ReportEventW_ndr_unpack");
		return NULL;
	}
	call = &ndr_table_eventlog.calls[11];

	pull = ndr_pull_init_blob(blob, object);
	if (pull == NULL) {
		PyErr_SetNdrError(NDR_ERR_ALLOC);
		return NULL;
	}

	pull->flags |= ndr_pull_flags;

	err = call->ndr_pull(pull, ndr_inout_flags, object);
	if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
		TALLOC_FREE(pull);
		PyErr_SetNdrError(err);
		return NULL;
	}
	if (!allow_remaining) {
		uint32_t highest_ofs;

		if (pull->offset > pull->relative_highest_offset) {
			highest_ofs = pull->offset;
		} else {
			highest_ofs = pull->relative_highest_offset;
		}
		if (highest_ofs < pull->data_size) {
			err = ndr_pull_error(pull, NDR_ERR_UNREAD_BYTES,
				"not all bytes consumed ofs[%u] size[%u]",
				highest_ofs, pull->data_size);
			TALLOC_FREE(pull);
			PyErr_SetNdrError(err);
			return NULL;
		}
	}

	TALLOC_FREE(pull);
	Py_RETURN_NONE;
}

static PyObject *py_eventlog_ReportEventW_ndr_unpack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	DATA_BLOB blob;
	Py_ssize_t blob_length = 0;
	const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
	PyObject *allow_remaining_obj = NULL;
	bool allow_remaining = false;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_in__",
		discard_const_p(char *, kwnames),
		&blob.data, &blob_length,
		&bigendian_obj,
		&ndr64_obj,
		&allow_remaining_obj)) {
		return NULL;
	}
	blob.length = blob_length;

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_NDR64;
	}

	if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
		allow_remaining = true;
	}

	return py_eventlog_ReportEventW_ndr_unpack(py_obj, &blob, NDR_IN, ndr_pull_flags, allow_remaining);
}

static PyObject *py_eventlog_ReportEventW_ndr_unpack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	DATA_BLOB blob;
	Py_ssize_t blob_length = 0;
	const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
	PyObject *allow_remaining_obj = NULL;
	bool allow_remaining = false;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_out__",
		discard_const_p(char *, kwnames),
		&blob.data, &blob_length,
		&bigendian_obj,
		&ndr64_obj,
		&allow_remaining_obj)) {
		return NULL;
	}
	blob.length = blob_length;

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_NDR64;
	}

	if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
		allow_remaining = true;
	}

	return py_eventlog_ReportEventW_ndr_unpack(py_obj, &blob, NDR_OUT, ndr_pull_flags, allow_remaining);
}

static PyObject *py_eventlog_ReportEventW_ndr_print(PyObject *py_obj, const char *name, int ndr_inout_flags)
{
	const struct ndr_interface_call *call = NULL;
	struct eventlog_ReportEventW *object = (struct eventlog_ReportEventW *)pytalloc_get_ptr(py_obj);
	PyObject *ret;
	char *retstr;

	if (ndr_table_eventlog.num_calls < 12) {
		PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_eventlog_ReportEventW_ndr_print");
		return NULL;
	}
	call = &ndr_table_eventlog.calls[11];

	retstr = ndr_print_function_string(pytalloc_get_mem_ctx(py_obj), call->ndr_print, name, ndr_inout_flags, object);
	ret = PyUnicode_FromString(retstr);
	TALLOC_FREE(retstr);

	return ret;
}

static PyObject *py_eventlog_ReportEventW_ndr_print_in(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
{
	return py_eventlog_ReportEventW_ndr_print(py_obj, "eventlog_ReportEventW_in", NDR_IN);
}

static PyObject *py_eventlog_ReportEventW_ndr_print_out(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
{
	return py_eventlog_ReportEventW_ndr_print(py_obj, "eventlog_ReportEventW_out", NDR_OUT);
}

static PyMethodDef py_eventlog_ReportEventW_methods[] = {
	{ "opnum", (PyCFunction)py_eventlog_ReportEventW_ndr_opnum, METH_NOARGS|METH_CLASS,
		"eventlog.ReportEventW.opnum() -> 11 (0x0b) " },
	{ "__ndr_pack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_ReportEventW_ndr_pack_in), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_pack_in(object, bigendian=False, ndr64=False) -> blob\nNDR pack input" },
	{ "__ndr_pack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_ReportEventW_ndr_pack_out), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_pack_out(object, bigendian=False, ndr64=False) -> blob\nNDR pack output" },
	{ "__ndr_unpack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_ReportEventW_ndr_unpack_in), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_unpack_in(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack input" },
	{ "__ndr_unpack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_ReportEventW_ndr_unpack_out), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_unpack_out(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack output" },
	{ "__ndr_print_in__", (PyCFunction)py_eventlog_ReportEventW_ndr_print_in, METH_NOARGS, "S.ndr_print_in(object) -> None\nNDR print input" },
	{ "__ndr_print_out__", (PyCFunction)py_eventlog_ReportEventW_ndr_print_out, METH_NOARGS, "S.ndr_print_out(object) -> None\nNDR print output" },
	{ NULL, NULL, 0, NULL }
};


static PyTypeObject eventlog_ReportEventW_Type = {
	PyVarObject_HEAD_INIT(NULL, 0)
	.tp_name = "eventlog.ReportEventW",
	.tp_getset = py_eventlog_ReportEventW_getsetters,
	.tp_methods = py_eventlog_ReportEventW_methods,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_new = py_eventlog_ReportEventW_new,
};

static bool pack_py_eventlog_ReportEventW_args_in(PyObject *args, PyObject *kwargs, struct eventlog_ReportEventW *r)
{
	PyObject *py_handle;
	PyObject *py_timestamp;
	PyObject *py_event_type;
	PyObject *py_event_category;
	PyObject *py_event_id;
	PyObject *py_servername;
	PyObject *py_user_sid;
	PyObject *py_strings;
	PyObject *py_data;
	PyObject *py_flags;
	PyObject *py_record_number;
	PyObject *py_time_written;
	const char *kwnames[] = {
		"handle", "timestamp", "event_type", "event_category", "event_id", "servername", "user_sid", "strings", "data", "flags", "record_number", "time_written", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOOOOOO:eventlog_ReportEventW", discard_const_p(char *, kwnames), &py_handle, &py_timestamp, &py_event_type, &py_event_category, &py_event_id, &py_servername, &py_user_sid, &py_strings, &py_data, &py_flags, &py_record_number, &py_time_written)) {
		return false;
	}

	if (py_handle == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.handle");
		return false;
	}
	r->in.handle = talloc_ptrtype(r, r->in.handle);
	if (r->in.handle == NULL) {
		PyErr_NoMemory();
		return false;
	}
	PY_CHECK_TYPE(policy_handle_Type, py_handle, return false;);
	if (talloc_reference(r, pytalloc_get_mem_ctx(py_handle)) == NULL) {
		PyErr_NoMemory();
		return false;
	}
	r->in.handle = (struct policy_handle *)pytalloc_get_ptr(py_handle);
	if (py_timestamp == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.timestamp");
		return false;
	}
	{
		const long long int_max = ndr_sizeof2intmax(sizeof(r->in.timestamp));
		const long long int_min = -int_max - 1;
		if (PyLong_Check(py_timestamp)) {
			long long test_var;
			test_var = PyLong_AsLongLong(py_timestamp);
			if (PyErr_Occurred() != NULL) {
				return false;
			}
			if (test_var < int_min || test_var > int_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range %lld - %lld, got %lld",\
				  PyLong_Type.tp_name, int_min, int_max, test_var);
				return false;
			}
			r->in.timestamp = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return false;
		}
	}
	if (py_event_type == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.event_type");
		return false;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.event_type));
		if (PyLong_Check(py_event_type)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(py_event_type);
			if (PyErr_Occurred() != NULL) {
				return false;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return false;
			}
			r->in.event_type = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return false;
		}
	}
	if (py_event_category == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.event_category");
		return false;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.event_category));
		if (PyLong_Check(py_event_category)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(py_event_category);
			if (PyErr_Occurred() != NULL) {
				return false;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return false;
			}
			r->in.event_category = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return false;
		}
	}
	if (py_event_id == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.event_id");
		return false;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.event_id));
		if (PyLong_Check(py_event_id)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(py_event_id);
			if (PyErr_Occurred() != NULL) {
				return false;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return false;
			}
			r->in.event_id = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return false;
		}
	}
	PY_CHECK_TYPE(&PyList_Type, py_strings, return false;);
	r->in.num_of_strings = PyList_GET_SIZE(py_strings);
	PY_CHECK_TYPE(&PyList_Type, py_data, return false;);
	r->in.data_size = PyList_GET_SIZE(py_data);
	if (py_servername == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.servername");
		return false;
	}
	r->in.servername = talloc_ptrtype(r, r->in.servername);
	if (r->in.servername == NULL) {
		PyErr_NoMemory();
		return false;
	}
	PY_CHECK_TYPE(lsa_String_Type, py_servername, return false;);
	if (talloc_reference(r, pytalloc_get_mem_ctx(py_servername)) == NULL) {
		PyErr_NoMemory();
		return false;
	}
	r->in.servername = (struct lsa_String *)pytalloc_get_ptr(py_servername);
	if (py_user_sid == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.user_sid");
		return false;
	}
	if (py_user_sid == Py_None) {
		r->in.user_sid = NULL;
	} else {
		r->in.user_sid = NULL;
		PY_CHECK_TYPE(dom_sid_Type, py_user_sid, return false;);
		if (talloc_reference(r, pytalloc_get_mem_ctx(py_user_sid)) == NULL) {
			PyErr_NoMemory();
			return false;
		}
		r->in.user_sid = (struct dom_sid *)pytalloc_get_ptr(py_user_sid);
	}
	if (py_strings == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.strings");
		return false;
	}
	if (py_strings == Py_None) {
		r->in.strings = NULL;
	} else {
		r->in.strings = NULL;
		PY_CHECK_TYPE(&PyList_Type, py_strings, return false;);
		{
			int strings_cntr_1;
			r->in.strings = talloc_array_ptrtype(r, r->in.strings, PyList_GET_SIZE(py_strings));
			if (!r->in.strings) { return false;; }
			talloc_set_name_const(r->in.strings, "ARRAY: r->in.strings");
			for (strings_cntr_1 = 0; strings_cntr_1 < PyList_GET_SIZE(py_strings); strings_cntr_1++) {
				if (PyList_GET_ITEM(py_strings, strings_cntr_1) == NULL) {
					PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.strings[strings_cntr_1]");
					return false;
				}
				if (PyList_GET_ITEM(py_strings, strings_cntr_1) == Py_None) {
					r->in.strings[strings_cntr_1] = NULL;
				} else {
					r->in.strings[strings_cntr_1] = NULL;
					PY_CHECK_TYPE(lsa_String_Type, PyList_GET_ITEM(py_strings, strings_cntr_1), return false;);
					if (talloc_reference(r->in.strings, pytalloc_get_mem_ctx(PyList_GET_ITEM(py_strings, strings_cntr_1))) == NULL) {
						PyErr_NoMemory();
						return false;
					}
					r->in.strings[strings_cntr_1] = (struct lsa_String *)pytalloc_get_ptr(PyList_GET_ITEM(py_strings, strings_cntr_1));
				}
			}
		}
	}
	if (py_data == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.data");
		return false;
	}
	if (py_data == Py_None) {
		r->in.data = NULL;
	} else {
		r->in.data = NULL;
		PY_CHECK_TYPE(&PyList_Type, py_data, return false;);
		{
			int data_cntr_1;
			r->in.data = talloc_array_ptrtype(r, r->in.data, PyList_GET_SIZE(py_data));
			if (!r->in.data) { return false;; }
			talloc_set_name_const(r->in.data, "ARRAY: r->in.data");
			for (data_cntr_1 = 0; data_cntr_1 < PyList_GET_SIZE(py_data); data_cntr_1++) {
				if (PyList_GET_ITEM(py_data, data_cntr_1) == NULL) {
					PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.data[data_cntr_1]");
					return false;
				}
				{
					const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.data[data_cntr_1]));
					if (PyLong_Check(PyList_GET_ITEM(py_data, data_cntr_1))) {
						unsigned long long test_var;
						test_var = PyLong_AsUnsignedLongLong(PyList_GET_ITEM(py_data, data_cntr_1));
						if (PyErr_Occurred() != NULL) {
							return false;
						}
						if (test_var > uint_max) {
							PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
							  PyLong_Type.tp_name, uint_max, test_var);
							return false;
						}
						r->in.data[data_cntr_1] = test_var;
					} else {
						PyErr_Format(PyExc_TypeError, "Expected type %s",\
						  PyLong_Type.tp_name);
						return false;
					}
				}
			}
		}
	}
	if (py_flags == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.flags");
		return false;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.flags));
		if (PyLong_Check(py_flags)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(py_flags);
			if (PyErr_Occurred() != NULL) {
				return false;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return false;
			}
			r->in.flags = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return false;
		}
	}
	if (py_record_number == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.record_number");
		return false;
	}
	if (py_record_number == Py_None) {
		r->in.record_number = NULL;
	} else {
		r->in.record_number = talloc_ptrtype(r, r->in.record_number);
		if (r->in.record_number == NULL) {
			PyErr_NoMemory();
			return false;
		}
		{
			const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(*r->in.record_number));
			if (PyLong_Check(py_record_number)) {
				unsigned long long test_var;
				test_var = PyLong_AsUnsignedLongLong(py_record_number);
				if (PyErr_Occurred() != NULL) {
					return false;
				}
				if (test_var > uint_max) {
					PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
					  PyLong_Type.tp_name, uint_max, test_var);
					return false;
				}
				*r->in.record_number = test_var;
			} else {
				PyErr_Format(PyExc_TypeError, "Expected type %s",\
				  PyLong_Type.tp_name);
				return false;
			}
		}
	}
	if (py_time_written == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.time_written");
		return false;
	}
	if (py_time_written == Py_None) {
		r->in.time_written = NULL;
	} else {
		r->in.time_written = talloc_ptrtype(r, r->in.time_written);
		if (r->in.time_written == NULL) {
			PyErr_NoMemory();
			return false;
		}
		{
			const long long int_max = ndr_sizeof2intmax(sizeof(*r->in.time_written));
			const long long int_min = -int_max - 1;
			if (PyLong_Check(py_time_written)) {
				long long test_var;
				test_var = PyLong_AsLongLong(py_time_written);
				if (PyErr_Occurred() != NULL) {
					return false;
				}
				if (test_var < int_min || test_var > int_max) {
					PyErr_Format(PyExc_OverflowError, "Expected type %s within range %lld - %lld, got %lld",\
					  PyLong_Type.tp_name, int_min, int_max, test_var);
					return false;
				}
				*r->in.time_written = test_var;
			} else {
				PyErr_Format(PyExc_TypeError, "Expected type %s",\
				  PyLong_Type.tp_name);
				return false;
			}
		}
	}
	return true;
}

static PyObject *unpack_py_eventlog_ReportEventW_args_out(struct eventlog_ReportEventW *r)
{
	PyObject *result;
	PyObject *py_record_number;
	PyObject *py_time_written;
	result = PyTuple_New(2);
	if (r->out.record_number == NULL) {
		py_record_number = Py_None;
		Py_INCREF(py_record_number);
	} else {
		py_record_number = PyLong_FromUnsignedLongLong((uint32_t)*r->out.record_number);
	}
	PyTuple_SetItem(result, 0, py_record_number);
	if (r->out.time_written == NULL) {
		py_time_written = Py_None;
		Py_INCREF(py_time_written);
	} else {
		py_time_written = PyLong_FromLong(*r->out.time_written);
	}
	PyTuple_SetItem(result, 1, py_time_written);
	if (NT_STATUS_IS_ERR(r->out.result)) {
		PyErr_SetNTSTATUS(r->out.result);
		return NULL;
	}

	return result;
}


static PyObject *py_eventlog_GetLogInformation_in_get_handle(PyObject *obj, void *closure)
{
	struct eventlog_GetLogInformation *object = (struct eventlog_GetLogInformation *)pytalloc_get_ptr(obj);
	PyObject *py_handle;
	if (object->in.handle == NULL) {
		Py_RETURN_NONE;
	}
	py_handle = pytalloc_reference_ex(policy_handle_Type, object->in.handle, object->in.handle);
	return py_handle;
}

static int py_eventlog_GetLogInformation_in_set_handle(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_GetLogInformation *object = (struct eventlog_GetLogInformation *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.handle));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.handle");
		return -1;
	}
	object->in.handle = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->in.handle);
	if (object->in.handle == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	PY_CHECK_TYPE(policy_handle_Type, value, return -1;);
	if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	object->in.handle = (struct policy_handle *)pytalloc_get_ptr(value);
	return 0;
}

static PyObject *py_eventlog_GetLogInformation_in_get_level(PyObject *obj, void *closure)
{
	struct eventlog_GetLogInformation *object = (struct eventlog_GetLogInformation *)pytalloc_get_ptr(obj);
	PyObject *py_level;
	py_level = PyLong_FromUnsignedLongLong((uint32_t)object->in.level);
	return py_level;
}

static int py_eventlog_GetLogInformation_in_set_level(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_GetLogInformation *object = (struct eventlog_GetLogInformation *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.level");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.level));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->in.level = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_GetLogInformation_out_get_buffer(PyObject *obj, void *closure)
{
	struct eventlog_GetLogInformation *object = (struct eventlog_GetLogInformation *)pytalloc_get_ptr(obj);
	PyObject *py_buffer;
	if (object->out.buffer == NULL) {
		Py_RETURN_NONE;
	}
	py_buffer = PyList_New(object->in.buf_size);
	if (py_buffer == NULL) {
		return NULL;
	}
	{
		int buffer_cntr_1;
		for (buffer_cntr_1 = 0; buffer_cntr_1 < (object->in.buf_size); buffer_cntr_1++) {
			PyObject *py_buffer_1;
			py_buffer_1 = PyLong_FromLong((uint16_t)object->out.buffer[buffer_cntr_1]);
			PyList_SetItem(py_buffer, buffer_cntr_1, py_buffer_1);
		}
	}
	return py_buffer;
}

static int py_eventlog_GetLogInformation_out_set_buffer(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_GetLogInformation *object = (struct eventlog_GetLogInformation *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->out.buffer));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->out.buffer");
		return -1;
	}
	object->out.buffer = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->out.buffer);
	if (object->out.buffer == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	PY_CHECK_TYPE(&PyList_Type, value, return -1;);
	{
		int buffer_cntr_1;
		object->out.buffer = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->out.buffer, PyList_GET_SIZE(value));
		if (!object->out.buffer) { return -1;; }
		talloc_set_name_const(object->out.buffer, "ARRAY: object->out.buffer");
		for (buffer_cntr_1 = 0; buffer_cntr_1 < PyList_GET_SIZE(value); buffer_cntr_1++) {
			if (PyList_GET_ITEM(value, buffer_cntr_1) == NULL) {
				PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->out.buffer[buffer_cntr_1]");
				return -1;
			}
			{
				const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->out.buffer[buffer_cntr_1]));
				if (PyLong_Check(PyList_GET_ITEM(value, buffer_cntr_1))) {
					unsigned long long test_var;
					test_var = PyLong_AsUnsignedLongLong(PyList_GET_ITEM(value, buffer_cntr_1));
					if (PyErr_Occurred() != NULL) {
						return -1;
					}
					if (test_var > uint_max) {
						PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
						  PyLong_Type.tp_name, uint_max, test_var);
						return -1;
					}
					object->out.buffer[buffer_cntr_1] = test_var;
				} else {
					PyErr_Format(PyExc_TypeError, "Expected type %s",\
					  PyLong_Type.tp_name);
					return -1;
				}
			}
		}
	}
	return 0;
}

static PyObject *py_eventlog_GetLogInformation_in_get_buf_size(PyObject *obj, void *closure)
{
	struct eventlog_GetLogInformation *object = (struct eventlog_GetLogInformation *)pytalloc_get_ptr(obj);
	PyObject *py_buf_size;
	py_buf_size = PyLong_FromUnsignedLongLong((uint32_t)object->in.buf_size);
	return py_buf_size;
}

static int py_eventlog_GetLogInformation_in_set_buf_size(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_GetLogInformation *object = (struct eventlog_GetLogInformation *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.buf_size");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.buf_size));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->in.buf_size = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_GetLogInformation_out_get_bytes_needed(PyObject *obj, void *closure)
{
	struct eventlog_GetLogInformation *object = (struct eventlog_GetLogInformation *)pytalloc_get_ptr(obj);
	PyObject *py_bytes_needed;
	if (object->out.bytes_needed == NULL) {
		Py_RETURN_NONE;
	}
	py_bytes_needed = PyLong_FromUnsignedLongLong((uint32_t)*object->out.bytes_needed);
	return py_bytes_needed;
}

static int py_eventlog_GetLogInformation_out_set_bytes_needed(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_GetLogInformation *object = (struct eventlog_GetLogInformation *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->out.bytes_needed));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->out.bytes_needed");
		return -1;
	}
	object->out.bytes_needed = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->out.bytes_needed);
	if (object->out.bytes_needed == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(*object->out.bytes_needed));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			*object->out.bytes_needed = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_GetLogInformation_get_result(PyObject *obj, void *closure)
{
	struct eventlog_GetLogInformation *object = (struct eventlog_GetLogInformation *)pytalloc_get_ptr(obj);
	PyObject *py_result;
	py_result = PyErr_FromNTSTATUS(object->out.result);
	return py_result;
}

static int py_eventlog_GetLogInformation_set_result(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_GetLogInformation *object = (struct eventlog_GetLogInformation *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->out.result");
		return -1;
	}
	object->out.result = NT_STATUS(PyLong_AsLong(value));
	return 0;
}

static PyGetSetDef py_eventlog_GetLogInformation_getsetters[] = {
	{
		.name = discard_const_p(char, "in_handle"),
		.get = py_eventlog_GetLogInformation_in_get_handle,
		.set = py_eventlog_GetLogInformation_in_set_handle,
		.doc = discard_const_p(char, "PIDL-generated element of base type policy_handle")
	},
	{
		.name = discard_const_p(char, "in_level"),
		.get = py_eventlog_GetLogInformation_in_get_level,
		.set = py_eventlog_GetLogInformation_in_set_level,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "out_buffer"),
		.get = py_eventlog_GetLogInformation_out_get_buffer,
		.set = py_eventlog_GetLogInformation_out_set_buffer,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint8")
	},
	{
		.name = discard_const_p(char, "in_buf_size"),
		.get = py_eventlog_GetLogInformation_in_get_buf_size,
		.set = py_eventlog_GetLogInformation_in_set_buf_size,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "out_bytes_needed"),
		.get = py_eventlog_GetLogInformation_out_get_bytes_needed,
		.set = py_eventlog_GetLogInformation_out_set_bytes_needed,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "result"),
		.get = py_eventlog_GetLogInformation_get_result,
		.set = py_eventlog_GetLogInformation_set_result,
		.doc = discard_const_p(char, "PIDL-generated element of type NTSTATUS")
	},
	{ .name = NULL }
};

static PyObject *py_eventlog_GetLogInformation_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	PyObject *self = pytalloc_new(struct eventlog_GetLogInformation, type);
	struct eventlog_GetLogInformation *_self = (struct eventlog_GetLogInformation *)pytalloc_get_ptr(self);
	TALLOC_CTX *mem_ctx = pytalloc_get_mem_ctx(self);
	_self->in.handle = talloc_zero(mem_ctx, struct policy_handle);
	_self->out.buffer = talloc_zero(mem_ctx, uint8_t);
	_self->out.bytes_needed = talloc_zero(mem_ctx, uint32_t);
	return self;
}

static PyObject *py_eventlog_GetLogInformation_ndr_opnum(PyTypeObject *type, PyObject *Py_UNUSED(ignored))
{


	return PyLong_FromLong(22);
}

static PyObject *py_eventlog_GetLogInformation_ndr_pack(PyObject *py_obj, int ndr_inout_flags, uint32_t ndr_push_flags)
{
	const struct ndr_interface_call *call = NULL;
	struct eventlog_GetLogInformation *object = (struct eventlog_GetLogInformation *)pytalloc_get_ptr(py_obj);
	PyObject *ret = NULL;
	struct ndr_push *push = NULL;
	DATA_BLOB blob;
	enum ndr_err_code err;

	if (ndr_table_eventlog.num_calls < 23) {
		PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_eventlog_GetLogInformation_ndr_pack");
		return NULL;
	}
	call = &ndr_table_eventlog.calls[22];

	push = ndr_push_init_ctx(pytalloc_get_mem_ctx(py_obj));
	if (push == NULL) {
		PyErr_SetNdrError(NDR_ERR_ALLOC);
		return NULL;
	}

	push->flags |= ndr_push_flags;

	err = call->ndr_push(push, ndr_inout_flags, object);
	if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
		TALLOC_FREE(push);
		PyErr_SetNdrError(err);
		return NULL;
	}
	blob = ndr_push_blob(push);
	ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
	TALLOC_FREE(push);
	return ret;
}

static PyObject *py_eventlog_GetLogInformation_ndr_pack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	const char * const kwnames[] = { "bigendian", "ndr64", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_push_flags = 0;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_in__",
		discard_const_p(char *, kwnames),
		&bigendian_obj,
		&ndr64_obj)) {
		return NULL;
	}

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_NDR64;
	}

	return py_eventlog_GetLogInformation_ndr_pack(py_obj, NDR_IN, ndr_push_flags);
}

static PyObject *py_eventlog_GetLogInformation_ndr_pack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	const char * const kwnames[] = { "bigendian", "ndr64", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_push_flags = 0;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_out__",
		discard_const_p(char *, kwnames),
		&bigendian_obj,
		&ndr64_obj)) {
		return NULL;
	}

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_NDR64;
	}

	return py_eventlog_GetLogInformation_ndr_pack(py_obj, NDR_OUT, ndr_push_flags);
}

static PyObject *py_eventlog_GetLogInformation_ndr_unpack(PyObject *py_obj, const DATA_BLOB *blob, int ndr_inout_flags, uint32_t ndr_pull_flags, bool allow_remaining)
{
	const struct ndr_interface_call *call = NULL;
	struct eventlog_GetLogInformation *object = (struct eventlog_GetLogInformation *)pytalloc_get_ptr(py_obj);
	struct ndr_pull *pull = NULL;
	enum ndr_err_code err;

	if (ndr_table_eventlog.num_calls < 23) {
		PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_eventlog_GetLogInformation_ndr_unpack");
		return NULL;
	}
	call = &ndr_table_eventlog.calls[22];

	pull = ndr_pull_init_blob(blob, object);
	if (pull == NULL) {
		PyErr_SetNdrError(NDR_ERR_ALLOC);
		return NULL;
	}

	pull->flags |= ndr_pull_flags;

	err = call->ndr_pull(pull, ndr_inout_flags, object);
	if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
		TALLOC_FREE(pull);
		PyErr_SetNdrError(err);
		return NULL;
	}
	if (!allow_remaining) {
		uint32_t highest_ofs;

		if (pull->offset > pull->relative_highest_offset) {
			highest_ofs = pull->offset;
		} else {
			highest_ofs = pull->relative_highest_offset;
		}
		if (highest_ofs < pull->data_size) {
			err = ndr_pull_error(pull, NDR_ERR_UNREAD_BYTES,
				"not all bytes consumed ofs[%u] size[%u]",
				highest_ofs, pull->data_size);
			TALLOC_FREE(pull);
			PyErr_SetNdrError(err);
			return NULL;
		}
	}

	TALLOC_FREE(pull);
	Py_RETURN_NONE;
}

static PyObject *py_eventlog_GetLogInformation_ndr_unpack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	DATA_BLOB blob;
	Py_ssize_t blob_length = 0;
	const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
	PyObject *allow_remaining_obj = NULL;
	bool allow_remaining = false;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_in__",
		discard_const_p(char *, kwnames),
		&blob.data, &blob_length,
		&bigendian_obj,
		&ndr64_obj,
		&allow_remaining_obj)) {
		return NULL;
	}
	blob.length = blob_length;

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_NDR64;
	}

	if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
		allow_remaining = true;
	}

	return py_eventlog_GetLogInformation_ndr_unpack(py_obj, &blob, NDR_IN, ndr_pull_flags, allow_remaining);
}

static PyObject *py_eventlog_GetLogInformation_ndr_unpack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	DATA_BLOB blob;
	Py_ssize_t blob_length = 0;
	const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
	PyObject *allow_remaining_obj = NULL;
	bool allow_remaining = false;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_out__",
		discard_const_p(char *, kwnames),
		&blob.data, &blob_length,
		&bigendian_obj,
		&ndr64_obj,
		&allow_remaining_obj)) {
		return NULL;
	}
	blob.length = blob_length;

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_NDR64;
	}

	if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
		allow_remaining = true;
	}

	return py_eventlog_GetLogInformation_ndr_unpack(py_obj, &blob, NDR_OUT, ndr_pull_flags, allow_remaining);
}

static PyObject *py_eventlog_GetLogInformation_ndr_print(PyObject *py_obj, const char *name, int ndr_inout_flags)
{
	const struct ndr_interface_call *call = NULL;
	struct eventlog_GetLogInformation *object = (struct eventlog_GetLogInformation *)pytalloc_get_ptr(py_obj);
	PyObject *ret;
	char *retstr;

	if (ndr_table_eventlog.num_calls < 23) {
		PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_eventlog_GetLogInformation_ndr_print");
		return NULL;
	}
	call = &ndr_table_eventlog.calls[22];

	retstr = ndr_print_function_string(pytalloc_get_mem_ctx(py_obj), call->ndr_print, name, ndr_inout_flags, object);
	ret = PyUnicode_FromString(retstr);
	TALLOC_FREE(retstr);

	return ret;
}

static PyObject *py_eventlog_GetLogInformation_ndr_print_in(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
{
	return py_eventlog_GetLogInformation_ndr_print(py_obj, "eventlog_GetLogInformation_in", NDR_IN);
}

static PyObject *py_eventlog_GetLogInformation_ndr_print_out(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
{
	return py_eventlog_GetLogInformation_ndr_print(py_obj, "eventlog_GetLogInformation_out", NDR_OUT);
}

static PyMethodDef py_eventlog_GetLogInformation_methods[] = {
	{ "opnum", (PyCFunction)py_eventlog_GetLogInformation_ndr_opnum, METH_NOARGS|METH_CLASS,
		"eventlog.GetLogInformation.opnum() -> 22 (0x16) " },
	{ "__ndr_pack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_GetLogInformation_ndr_pack_in), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_pack_in(object, bigendian=False, ndr64=False) -> blob\nNDR pack input" },
	{ "__ndr_pack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_GetLogInformation_ndr_pack_out), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_pack_out(object, bigendian=False, ndr64=False) -> blob\nNDR pack output" },
	{ "__ndr_unpack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_GetLogInformation_ndr_unpack_in), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_unpack_in(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack input" },
	{ "__ndr_unpack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_GetLogInformation_ndr_unpack_out), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_unpack_out(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack output" },
	{ "__ndr_print_in__", (PyCFunction)py_eventlog_GetLogInformation_ndr_print_in, METH_NOARGS, "S.ndr_print_in(object) -> None\nNDR print input" },
	{ "__ndr_print_out__", (PyCFunction)py_eventlog_GetLogInformation_ndr_print_out, METH_NOARGS, "S.ndr_print_out(object) -> None\nNDR print output" },
	{ NULL, NULL, 0, NULL }
};


static PyTypeObject eventlog_GetLogInformation_Type = {
	PyVarObject_HEAD_INIT(NULL, 0)
	.tp_name = "eventlog.GetLogInformation",
	.tp_getset = py_eventlog_GetLogInformation_getsetters,
	.tp_methods = py_eventlog_GetLogInformation_methods,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_new = py_eventlog_GetLogInformation_new,
};

static bool pack_py_eventlog_GetLogInformation_args_in(PyObject *args, PyObject *kwargs, struct eventlog_GetLogInformation *r)
{
	PyObject *py_handle;
	PyObject *py_level;
	PyObject *py_buf_size;
	const char *kwnames[] = {
		"handle", "level", "buf_size", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:eventlog_GetLogInformation", discard_const_p(char *, kwnames), &py_handle, &py_level, &py_buf_size)) {
		return false;
	}

	if (py_handle == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.handle");
		return false;
	}
	r->in.handle = talloc_ptrtype(r, r->in.handle);
	if (r->in.handle == NULL) {
		PyErr_NoMemory();
		return false;
	}
	PY_CHECK_TYPE(policy_handle_Type, py_handle, return false;);
	if (talloc_reference(r, pytalloc_get_mem_ctx(py_handle)) == NULL) {
		PyErr_NoMemory();
		return false;
	}
	r->in.handle = (struct policy_handle *)pytalloc_get_ptr(py_handle);
	if (py_level == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.level");
		return false;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.level));
		if (PyLong_Check(py_level)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(py_level);
			if (PyErr_Occurred() != NULL) {
				return false;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return false;
			}
			r->in.level = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return false;
		}
	}
	if (py_buf_size == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.buf_size");
		return false;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.buf_size));
		if (PyLong_Check(py_buf_size)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(py_buf_size);
			if (PyErr_Occurred() != NULL) {
				return false;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return false;
			}
			r->in.buf_size = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return false;
		}
	}
	return true;
}

static PyObject *unpack_py_eventlog_GetLogInformation_args_out(struct eventlog_GetLogInformation *r)
{
	PyObject *result;
	PyObject *py_buffer;
	PyObject *py_bytes_needed;
	result = PyTuple_New(2);
	py_buffer = PyList_New(r->in.buf_size);
	if (py_buffer == NULL) {
		return NULL;
	}
	{
		int buffer_cntr_1;
		for (buffer_cntr_1 = 0; buffer_cntr_1 < (r->in.buf_size); buffer_cntr_1++) {
			PyObject *py_buffer_1;
			py_buffer_1 = PyLong_FromLong((uint16_t)r->out.buffer[buffer_cntr_1]);
			PyList_SetItem(py_buffer, buffer_cntr_1, py_buffer_1);
		}
	}
	PyTuple_SetItem(result, 0, py_buffer);
	py_bytes_needed = PyLong_FromUnsignedLongLong((uint32_t)*r->out.bytes_needed);
	PyTuple_SetItem(result, 1, py_bytes_needed);
	if (NT_STATUS_IS_ERR(r->out.result)) {
		PyErr_SetNTSTATUS(r->out.result);
		return NULL;
	}

	return result;
}


static PyObject *py_eventlog_FlushEventLog_in_get_handle(PyObject *obj, void *closure)
{
	struct eventlog_FlushEventLog *object = (struct eventlog_FlushEventLog *)pytalloc_get_ptr(obj);
	PyObject *py_handle;
	if (object->in.handle == NULL) {
		Py_RETURN_NONE;
	}
	py_handle = pytalloc_reference_ex(policy_handle_Type, object->in.handle, object->in.handle);
	return py_handle;
}

static int py_eventlog_FlushEventLog_in_set_handle(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_FlushEventLog *object = (struct eventlog_FlushEventLog *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.handle));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.handle");
		return -1;
	}
	object->in.handle = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->in.handle);
	if (object->in.handle == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	PY_CHECK_TYPE(policy_handle_Type, value, return -1;);
	if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	object->in.handle = (struct policy_handle *)pytalloc_get_ptr(value);
	return 0;
}

static PyObject *py_eventlog_FlushEventLog_get_result(PyObject *obj, void *closure)
{
	struct eventlog_FlushEventLog *object = (struct eventlog_FlushEventLog *)pytalloc_get_ptr(obj);
	PyObject *py_result;
	py_result = PyErr_FromNTSTATUS(object->out.result);
	return py_result;
}

static int py_eventlog_FlushEventLog_set_result(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_FlushEventLog *object = (struct eventlog_FlushEventLog *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->out.result");
		return -1;
	}
	object->out.result = NT_STATUS(PyLong_AsLong(value));
	return 0;
}

static PyGetSetDef py_eventlog_FlushEventLog_getsetters[] = {
	{
		.name = discard_const_p(char, "in_handle"),
		.get = py_eventlog_FlushEventLog_in_get_handle,
		.set = py_eventlog_FlushEventLog_in_set_handle,
		.doc = discard_const_p(char, "PIDL-generated element of base type policy_handle")
	},
	{
		.name = discard_const_p(char, "result"),
		.get = py_eventlog_FlushEventLog_get_result,
		.set = py_eventlog_FlushEventLog_set_result,
		.doc = discard_const_p(char, "PIDL-generated element of type NTSTATUS")
	},
	{ .name = NULL }
};

static PyObject *py_eventlog_FlushEventLog_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	PyObject *self = pytalloc_new(struct eventlog_FlushEventLog, type);
	struct eventlog_FlushEventLog *_self = (struct eventlog_FlushEventLog *)pytalloc_get_ptr(self);
	TALLOC_CTX *mem_ctx = pytalloc_get_mem_ctx(self);
	_self->in.handle = talloc_zero(mem_ctx, struct policy_handle);
	return self;
}

static PyObject *py_eventlog_FlushEventLog_ndr_opnum(PyTypeObject *type, PyObject *Py_UNUSED(ignored))
{


	return PyLong_FromLong(23);
}

static PyObject *py_eventlog_FlushEventLog_ndr_pack(PyObject *py_obj, int ndr_inout_flags, uint32_t ndr_push_flags)
{
	const struct ndr_interface_call *call = NULL;
	struct eventlog_FlushEventLog *object = (struct eventlog_FlushEventLog *)pytalloc_get_ptr(py_obj);
	PyObject *ret = NULL;
	struct ndr_push *push = NULL;
	DATA_BLOB blob;
	enum ndr_err_code err;

	if (ndr_table_eventlog.num_calls < 24) {
		PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_eventlog_FlushEventLog_ndr_pack");
		return NULL;
	}
	call = &ndr_table_eventlog.calls[23];

	push = ndr_push_init_ctx(pytalloc_get_mem_ctx(py_obj));
	if (push == NULL) {
		PyErr_SetNdrError(NDR_ERR_ALLOC);
		return NULL;
	}

	push->flags |= ndr_push_flags;

	err = call->ndr_push(push, ndr_inout_flags, object);
	if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
		TALLOC_FREE(push);
		PyErr_SetNdrError(err);
		return NULL;
	}
	blob = ndr_push_blob(push);
	ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
	TALLOC_FREE(push);
	return ret;
}

static PyObject *py_eventlog_FlushEventLog_ndr_pack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	const char * const kwnames[] = { "bigendian", "ndr64", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_push_flags = 0;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_in__",
		discard_const_p(char *, kwnames),
		&bigendian_obj,
		&ndr64_obj)) {
		return NULL;
	}

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_NDR64;
	}

	return py_eventlog_FlushEventLog_ndr_pack(py_obj, NDR_IN, ndr_push_flags);
}

static PyObject *py_eventlog_FlushEventLog_ndr_pack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	const char * const kwnames[] = { "bigendian", "ndr64", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_push_flags = 0;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_out__",
		discard_const_p(char *, kwnames),
		&bigendian_obj,
		&ndr64_obj)) {
		return NULL;
	}

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_NDR64;
	}

	return py_eventlog_FlushEventLog_ndr_pack(py_obj, NDR_OUT, ndr_push_flags);
}

static PyObject *py_eventlog_FlushEventLog_ndr_unpack(PyObject *py_obj, const DATA_BLOB *blob, int ndr_inout_flags, uint32_t ndr_pull_flags, bool allow_remaining)
{
	const struct ndr_interface_call *call = NULL;
	struct eventlog_FlushEventLog *object = (struct eventlog_FlushEventLog *)pytalloc_get_ptr(py_obj);
	struct ndr_pull *pull = NULL;
	enum ndr_err_code err;

	if (ndr_table_eventlog.num_calls < 24) {
		PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_eventlog_FlushEventLog_ndr_unpack");
		return NULL;
	}
	call = &ndr_table_eventlog.calls[23];

	pull = ndr_pull_init_blob(blob, object);
	if (pull == NULL) {
		PyErr_SetNdrError(NDR_ERR_ALLOC);
		return NULL;
	}

	pull->flags |= ndr_pull_flags;

	err = call->ndr_pull(pull, ndr_inout_flags, object);
	if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
		TALLOC_FREE(pull);
		PyErr_SetNdrError(err);
		return NULL;
	}
	if (!allow_remaining) {
		uint32_t highest_ofs;

		if (pull->offset > pull->relative_highest_offset) {
			highest_ofs = pull->offset;
		} else {
			highest_ofs = pull->relative_highest_offset;
		}
		if (highest_ofs < pull->data_size) {
			err = ndr_pull_error(pull, NDR_ERR_UNREAD_BYTES,
				"not all bytes consumed ofs[%u] size[%u]",
				highest_ofs, pull->data_size);
			TALLOC_FREE(pull);
			PyErr_SetNdrError(err);
			return NULL;
		}
	}

	TALLOC_FREE(pull);
	Py_RETURN_NONE;
}

static PyObject *py_eventlog_FlushEventLog_ndr_unpack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	DATA_BLOB blob;
	Py_ssize_t blob_length = 0;
	const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
	PyObject *allow_remaining_obj = NULL;
	bool allow_remaining = false;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_in__",
		discard_const_p(char *, kwnames),
		&blob.data, &blob_length,
		&bigendian_obj,
		&ndr64_obj,
		&allow_remaining_obj)) {
		return NULL;
	}
	blob.length = blob_length;

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_NDR64;
	}

	if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
		allow_remaining = true;
	}

	return py_eventlog_FlushEventLog_ndr_unpack(py_obj, &blob, NDR_IN, ndr_pull_flags, allow_remaining);
}

static PyObject *py_eventlog_FlushEventLog_ndr_unpack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	DATA_BLOB blob;
	Py_ssize_t blob_length = 0;
	const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
	PyObject *allow_remaining_obj = NULL;
	bool allow_remaining = false;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_out__",
		discard_const_p(char *, kwnames),
		&blob.data, &blob_length,
		&bigendian_obj,
		&ndr64_obj,
		&allow_remaining_obj)) {
		return NULL;
	}
	blob.length = blob_length;

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_NDR64;
	}

	if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
		allow_remaining = true;
	}

	return py_eventlog_FlushEventLog_ndr_unpack(py_obj, &blob, NDR_OUT, ndr_pull_flags, allow_remaining);
}

static PyObject *py_eventlog_FlushEventLog_ndr_print(PyObject *py_obj, const char *name, int ndr_inout_flags)
{
	const struct ndr_interface_call *call = NULL;
	struct eventlog_FlushEventLog *object = (struct eventlog_FlushEventLog *)pytalloc_get_ptr(py_obj);
	PyObject *ret;
	char *retstr;

	if (ndr_table_eventlog.num_calls < 24) {
		PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_eventlog_FlushEventLog_ndr_print");
		return NULL;
	}
	call = &ndr_table_eventlog.calls[23];

	retstr = ndr_print_function_string(pytalloc_get_mem_ctx(py_obj), call->ndr_print, name, ndr_inout_flags, object);
	ret = PyUnicode_FromString(retstr);
	TALLOC_FREE(retstr);

	return ret;
}

static PyObject *py_eventlog_FlushEventLog_ndr_print_in(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
{
	return py_eventlog_FlushEventLog_ndr_print(py_obj, "eventlog_FlushEventLog_in", NDR_IN);
}

static PyObject *py_eventlog_FlushEventLog_ndr_print_out(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
{
	return py_eventlog_FlushEventLog_ndr_print(py_obj, "eventlog_FlushEventLog_out", NDR_OUT);
}

static PyMethodDef py_eventlog_FlushEventLog_methods[] = {
	{ "opnum", (PyCFunction)py_eventlog_FlushEventLog_ndr_opnum, METH_NOARGS|METH_CLASS,
		"eventlog.FlushEventLog.opnum() -> 23 (0x17) " },
	{ "__ndr_pack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_FlushEventLog_ndr_pack_in), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_pack_in(object, bigendian=False, ndr64=False) -> blob\nNDR pack input" },
	{ "__ndr_pack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_FlushEventLog_ndr_pack_out), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_pack_out(object, bigendian=False, ndr64=False) -> blob\nNDR pack output" },
	{ "__ndr_unpack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_FlushEventLog_ndr_unpack_in), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_unpack_in(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack input" },
	{ "__ndr_unpack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_FlushEventLog_ndr_unpack_out), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_unpack_out(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack output" },
	{ "__ndr_print_in__", (PyCFunction)py_eventlog_FlushEventLog_ndr_print_in, METH_NOARGS, "S.ndr_print_in(object) -> None\nNDR print input" },
	{ "__ndr_print_out__", (PyCFunction)py_eventlog_FlushEventLog_ndr_print_out, METH_NOARGS, "S.ndr_print_out(object) -> None\nNDR print output" },
	{ NULL, NULL, 0, NULL }
};


static PyTypeObject eventlog_FlushEventLog_Type = {
	PyVarObject_HEAD_INIT(NULL, 0)
	.tp_name = "eventlog.FlushEventLog",
	.tp_getset = py_eventlog_FlushEventLog_getsetters,
	.tp_methods = py_eventlog_FlushEventLog_methods,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_new = py_eventlog_FlushEventLog_new,
};

static bool pack_py_eventlog_FlushEventLog_args_in(PyObject *args, PyObject *kwargs, struct eventlog_FlushEventLog *r)
{
	PyObject *py_handle;
	const char *kwnames[] = {
		"handle", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:eventlog_FlushEventLog", discard_const_p(char *, kwnames), &py_handle)) {
		return false;
	}

	if (py_handle == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.handle");
		return false;
	}
	r->in.handle = talloc_ptrtype(r, r->in.handle);
	if (r->in.handle == NULL) {
		PyErr_NoMemory();
		return false;
	}
	PY_CHECK_TYPE(policy_handle_Type, py_handle, return false;);
	if (talloc_reference(r, pytalloc_get_mem_ctx(py_handle)) == NULL) {
		PyErr_NoMemory();
		return false;
	}
	r->in.handle = (struct policy_handle *)pytalloc_get_ptr(py_handle);
	return true;
}

static PyObject *unpack_py_eventlog_FlushEventLog_args_out(struct eventlog_FlushEventLog *r)
{
	PyObject *result;
	result = Py_None;
	Py_INCREF(result);
	if (NT_STATUS_IS_ERR(r->out.result)) {
		PyErr_SetNTSTATUS(r->out.result);
		return NULL;
	}

	return result;
}


static PyObject *py_eventlog_ReportEventAndSourceW_in_get_handle(PyObject *obj, void *closure)
{
	struct eventlog_ReportEventAndSourceW *object = (struct eventlog_ReportEventAndSourceW *)pytalloc_get_ptr(obj);
	PyObject *py_handle;
	if (object->in.handle == NULL) {
		Py_RETURN_NONE;
	}
	py_handle = pytalloc_reference_ex(policy_handle_Type, object->in.handle, object->in.handle);
	return py_handle;
}

static int py_eventlog_ReportEventAndSourceW_in_set_handle(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_ReportEventAndSourceW *object = (struct eventlog_ReportEventAndSourceW *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.handle));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.handle");
		return -1;
	}
	object->in.handle = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->in.handle);
	if (object->in.handle == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	PY_CHECK_TYPE(policy_handle_Type, value, return -1;);
	if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	object->in.handle = (struct policy_handle *)pytalloc_get_ptr(value);
	return 0;
}

static PyObject *py_eventlog_ReportEventAndSourceW_in_get_timestamp(PyObject *obj, void *closure)
{
	struct eventlog_ReportEventAndSourceW *object = (struct eventlog_ReportEventAndSourceW *)pytalloc_get_ptr(obj);
	PyObject *py_timestamp;
	py_timestamp = PyLong_FromLong(object->in.timestamp);
	return py_timestamp;
}

static int py_eventlog_ReportEventAndSourceW_in_set_timestamp(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_ReportEventAndSourceW *object = (struct eventlog_ReportEventAndSourceW *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.timestamp");
		return -1;
	}
	{
		const long long int_max = ndr_sizeof2intmax(sizeof(object->in.timestamp));
		const long long int_min = -int_max - 1;
		if (PyLong_Check(value)) {
			long long test_var;
			test_var = PyLong_AsLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var < int_min || test_var > int_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range %lld - %lld, got %lld",\
				  PyLong_Type.tp_name, int_min, int_max, test_var);
				return -1;
			}
			object->in.timestamp = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_ReportEventAndSourceW_in_get_event_type(PyObject *obj, void *closure)
{
	struct eventlog_ReportEventAndSourceW *object = (struct eventlog_ReportEventAndSourceW *)pytalloc_get_ptr(obj);
	PyObject *py_event_type;
	py_event_type = PyLong_FromLong((uint16_t)object->in.event_type);
	return py_event_type;
}

static int py_eventlog_ReportEventAndSourceW_in_set_event_type(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_ReportEventAndSourceW *object = (struct eventlog_ReportEventAndSourceW *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.event_type");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.event_type));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->in.event_type = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_ReportEventAndSourceW_in_get_event_category(PyObject *obj, void *closure)
{
	struct eventlog_ReportEventAndSourceW *object = (struct eventlog_ReportEventAndSourceW *)pytalloc_get_ptr(obj);
	PyObject *py_event_category;
	py_event_category = PyLong_FromLong((uint16_t)object->in.event_category);
	return py_event_category;
}

static int py_eventlog_ReportEventAndSourceW_in_set_event_category(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_ReportEventAndSourceW *object = (struct eventlog_ReportEventAndSourceW *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.event_category");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.event_category));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->in.event_category = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_ReportEventAndSourceW_in_get_event_id(PyObject *obj, void *closure)
{
	struct eventlog_ReportEventAndSourceW *object = (struct eventlog_ReportEventAndSourceW *)pytalloc_get_ptr(obj);
	PyObject *py_event_id;
	py_event_id = PyLong_FromUnsignedLongLong((uint32_t)object->in.event_id);
	return py_event_id;
}

static int py_eventlog_ReportEventAndSourceW_in_set_event_id(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_ReportEventAndSourceW *object = (struct eventlog_ReportEventAndSourceW *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.event_id");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.event_id));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->in.event_id = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_ReportEventAndSourceW_in_get_sourcename(PyObject *obj, void *closure)
{
	struct eventlog_ReportEventAndSourceW *object = (struct eventlog_ReportEventAndSourceW *)pytalloc_get_ptr(obj);
	PyObject *py_sourcename;
	if (object->in.sourcename == NULL) {
		Py_RETURN_NONE;
	}
	py_sourcename = pytalloc_reference_ex(lsa_String_Type, object->in.sourcename, object->in.sourcename);
	return py_sourcename;
}

static int py_eventlog_ReportEventAndSourceW_in_set_sourcename(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_ReportEventAndSourceW *object = (struct eventlog_ReportEventAndSourceW *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.sourcename));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.sourcename");
		return -1;
	}
	object->in.sourcename = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->in.sourcename);
	if (object->in.sourcename == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	PY_CHECK_TYPE(lsa_String_Type, value, return -1;);
	if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	object->in.sourcename = (struct lsa_String *)pytalloc_get_ptr(value);
	return 0;
}

static PyObject *py_eventlog_ReportEventAndSourceW_in_get_num_of_strings(PyObject *obj, void *closure)
{
	struct eventlog_ReportEventAndSourceW *object = (struct eventlog_ReportEventAndSourceW *)pytalloc_get_ptr(obj);
	PyObject *py_num_of_strings;
	py_num_of_strings = PyLong_FromLong((uint16_t)object->in.num_of_strings);
	return py_num_of_strings;
}

static int py_eventlog_ReportEventAndSourceW_in_set_num_of_strings(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_ReportEventAndSourceW *object = (struct eventlog_ReportEventAndSourceW *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.num_of_strings");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.num_of_strings));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->in.num_of_strings = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_ReportEventAndSourceW_in_get_data_size(PyObject *obj, void *closure)
{
	struct eventlog_ReportEventAndSourceW *object = (struct eventlog_ReportEventAndSourceW *)pytalloc_get_ptr(obj);
	PyObject *py_data_size;
	py_data_size = PyLong_FromUnsignedLongLong((uint32_t)object->in.data_size);
	return py_data_size;
}

static int py_eventlog_ReportEventAndSourceW_in_set_data_size(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_ReportEventAndSourceW *object = (struct eventlog_ReportEventAndSourceW *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.data_size");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.data_size));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->in.data_size = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_ReportEventAndSourceW_in_get_servername(PyObject *obj, void *closure)
{
	struct eventlog_ReportEventAndSourceW *object = (struct eventlog_ReportEventAndSourceW *)pytalloc_get_ptr(obj);
	PyObject *py_servername;
	if (object->in.servername == NULL) {
		Py_RETURN_NONE;
	}
	py_servername = pytalloc_reference_ex(lsa_String_Type, object->in.servername, object->in.servername);
	return py_servername;
}

static int py_eventlog_ReportEventAndSourceW_in_set_servername(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_ReportEventAndSourceW *object = (struct eventlog_ReportEventAndSourceW *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.servername));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.servername");
		return -1;
	}
	object->in.servername = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->in.servername);
	if (object->in.servername == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	PY_CHECK_TYPE(lsa_String_Type, value, return -1;);
	if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
		PyErr_NoMemory();
		return -1;
	}
	object->in.servername = (struct lsa_String *)pytalloc_get_ptr(value);
	return 0;
}

static PyObject *py_eventlog_ReportEventAndSourceW_in_get_user_sid(PyObject *obj, void *closure)
{
	struct eventlog_ReportEventAndSourceW *object = (struct eventlog_ReportEventAndSourceW *)pytalloc_get_ptr(obj);
	PyObject *py_user_sid;
	if (object->in.user_sid == NULL) {
		Py_RETURN_NONE;
	}
	if (object->in.user_sid == NULL) {
		py_user_sid = Py_None;
		Py_INCREF(py_user_sid);
	} else {
		py_user_sid = pytalloc_reference_ex(dom_sid_Type, object->in.user_sid, object->in.user_sid);
	}
	return py_user_sid;
}

static int py_eventlog_ReportEventAndSourceW_in_set_user_sid(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_ReportEventAndSourceW *object = (struct eventlog_ReportEventAndSourceW *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.user_sid));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.user_sid");
		return -1;
	}
	if (value == Py_None) {
		object->in.user_sid = NULL;
	} else {
		object->in.user_sid = NULL;
		PY_CHECK_TYPE(dom_sid_Type, value, return -1;);
		if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
			PyErr_NoMemory();
			return -1;
		}
		object->in.user_sid = (struct dom_sid *)pytalloc_get_ptr(value);
	}
	return 0;
}

static PyObject *py_eventlog_ReportEventAndSourceW_in_get_strings(PyObject *obj, void *closure)
{
	struct eventlog_ReportEventAndSourceW *object = (struct eventlog_ReportEventAndSourceW *)pytalloc_get_ptr(obj);
	PyObject *py_strings;
	if (object->in.strings == NULL) {
		Py_RETURN_NONE;
	}
	if (object->in.strings == NULL) {
		py_strings = Py_None;
		Py_INCREF(py_strings);
	} else {
		py_strings = PyList_New(object->in.num_of_strings);
		if (py_strings == NULL) {
			return NULL;
		}
		{
			int strings_cntr_1;
			for (strings_cntr_1 = 0; strings_cntr_1 < (object->in.num_of_strings); strings_cntr_1++) {
				PyObject *py_strings_1;
				if (object->in.strings[strings_cntr_1] == NULL) {
					py_strings_1 = Py_None;
					Py_INCREF(py_strings_1);
				} else {
					py_strings_1 = pytalloc_reference_ex(lsa_String_Type, object->in.strings[strings_cntr_1], object->in.strings[strings_cntr_1]);
				}
				PyList_SetItem(py_strings, strings_cntr_1, py_strings_1);
			}
		}
	}
	return py_strings;
}

static int py_eventlog_ReportEventAndSourceW_in_set_strings(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_ReportEventAndSourceW *object = (struct eventlog_ReportEventAndSourceW *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.strings));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.strings");
		return -1;
	}
	if (value == Py_None) {
		object->in.strings = NULL;
	} else {
		object->in.strings = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int strings_cntr_1;
			object->in.strings = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->in.strings, PyList_GET_SIZE(value));
			if (!object->in.strings) { return -1;; }
			talloc_set_name_const(object->in.strings, "ARRAY: object->in.strings");
			for (strings_cntr_1 = 0; strings_cntr_1 < PyList_GET_SIZE(value); strings_cntr_1++) {
				if (PyList_GET_ITEM(value, strings_cntr_1) == NULL) {
					PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.strings[strings_cntr_1]");
					return -1;
				}
				if (PyList_GET_ITEM(value, strings_cntr_1) == Py_None) {
					object->in.strings[strings_cntr_1] = NULL;
				} else {
					object->in.strings[strings_cntr_1] = NULL;
					PY_CHECK_TYPE(lsa_String_Type, PyList_GET_ITEM(value, strings_cntr_1), return -1;);
					if (talloc_reference(object->in.strings, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, strings_cntr_1))) == NULL) {
						PyErr_NoMemory();
						return -1;
					}
					object->in.strings[strings_cntr_1] = (struct lsa_String *)pytalloc_get_ptr(PyList_GET_ITEM(value, strings_cntr_1));
				}
			}
		}
	}
	return 0;
}

static PyObject *py_eventlog_ReportEventAndSourceW_in_get_data(PyObject *obj, void *closure)
{
	struct eventlog_ReportEventAndSourceW *object = (struct eventlog_ReportEventAndSourceW *)pytalloc_get_ptr(obj);
	PyObject *py_data;
	if (object->in.data == NULL) {
		Py_RETURN_NONE;
	}
	if (object->in.data == NULL) {
		py_data = Py_None;
		Py_INCREF(py_data);
	} else {
		py_data = PyList_New(object->in.data_size);
		if (py_data == NULL) {
			return NULL;
		}
		{
			int data_cntr_1;
			for (data_cntr_1 = 0; data_cntr_1 < (object->in.data_size); data_cntr_1++) {
				PyObject *py_data_1;
				py_data_1 = PyLong_FromLong((uint16_t)object->in.data[data_cntr_1]);
				PyList_SetItem(py_data, data_cntr_1, py_data_1);
			}
		}
	}
	return py_data;
}

static int py_eventlog_ReportEventAndSourceW_in_set_data(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_ReportEventAndSourceW *object = (struct eventlog_ReportEventAndSourceW *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.data));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.data");
		return -1;
	}
	if (value == Py_None) {
		object->in.data = NULL;
	} else {
		object->in.data = NULL;
		PY_CHECK_TYPE(&PyList_Type, value, return -1;);
		{
			int data_cntr_1;
			object->in.data = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->in.data, PyList_GET_SIZE(value));
			if (!object->in.data) { return -1;; }
			talloc_set_name_const(object->in.data, "ARRAY: object->in.data");
			for (data_cntr_1 = 0; data_cntr_1 < PyList_GET_SIZE(value); data_cntr_1++) {
				if (PyList_GET_ITEM(value, data_cntr_1) == NULL) {
					PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.data[data_cntr_1]");
					return -1;
				}
				{
					const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.data[data_cntr_1]));
					if (PyLong_Check(PyList_GET_ITEM(value, data_cntr_1))) {
						unsigned long long test_var;
						test_var = PyLong_AsUnsignedLongLong(PyList_GET_ITEM(value, data_cntr_1));
						if (PyErr_Occurred() != NULL) {
							return -1;
						}
						if (test_var > uint_max) {
							PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
							  PyLong_Type.tp_name, uint_max, test_var);
							return -1;
						}
						object->in.data[data_cntr_1] = test_var;
					} else {
						PyErr_Format(PyExc_TypeError, "Expected type %s",\
						  PyLong_Type.tp_name);
						return -1;
					}
				}
			}
		}
	}
	return 0;
}

static PyObject *py_eventlog_ReportEventAndSourceW_in_get_flags(PyObject *obj, void *closure)
{
	struct eventlog_ReportEventAndSourceW *object = (struct eventlog_ReportEventAndSourceW *)pytalloc_get_ptr(obj);
	PyObject *py_flags;
	py_flags = PyLong_FromLong((uint16_t)object->in.flags);
	return py_flags;
}

static int py_eventlog_ReportEventAndSourceW_in_set_flags(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_ReportEventAndSourceW *object = (struct eventlog_ReportEventAndSourceW *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.flags");
		return -1;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.flags));
		if (PyLong_Check(value)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(value);
			if (PyErr_Occurred() != NULL) {
				return -1;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return -1;
			}
			object->in.flags = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return -1;
		}
	}
	return 0;
}

static PyObject *py_eventlog_ReportEventAndSourceW_in_get_record_number(PyObject *obj, void *closure)
{
	struct eventlog_ReportEventAndSourceW *object = (struct eventlog_ReportEventAndSourceW *)pytalloc_get_ptr(obj);
	PyObject *py_record_number;
	if (object->in.record_number == NULL) {
		Py_RETURN_NONE;
	}
	if (object->in.record_number == NULL) {
		py_record_number = Py_None;
		Py_INCREF(py_record_number);
	} else {
		py_record_number = PyLong_FromUnsignedLongLong((uint32_t)*object->in.record_number);
	}
	return py_record_number;
}

static int py_eventlog_ReportEventAndSourceW_in_set_record_number(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_ReportEventAndSourceW *object = (struct eventlog_ReportEventAndSourceW *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.record_number));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.record_number");
		return -1;
	}
	if (value == Py_None) {
		object->in.record_number = NULL;
	} else {
		object->in.record_number = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->in.record_number);
		if (object->in.record_number == NULL) {
			PyErr_NoMemory();
			return -1;
		}
		{
			const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(*object->in.record_number));
			if (PyLong_Check(value)) {
				unsigned long long test_var;
				test_var = PyLong_AsUnsignedLongLong(value);
				if (PyErr_Occurred() != NULL) {
					return -1;
				}
				if (test_var > uint_max) {
					PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
					  PyLong_Type.tp_name, uint_max, test_var);
					return -1;
				}
				*object->in.record_number = test_var;
			} else {
				PyErr_Format(PyExc_TypeError, "Expected type %s",\
				  PyLong_Type.tp_name);
				return -1;
			}
		}
	}
	return 0;
}

static PyObject *py_eventlog_ReportEventAndSourceW_out_get_record_number(PyObject *obj, void *closure)
{
	struct eventlog_ReportEventAndSourceW *object = (struct eventlog_ReportEventAndSourceW *)pytalloc_get_ptr(obj);
	PyObject *py_record_number;
	if (object->out.record_number == NULL) {
		Py_RETURN_NONE;
	}
	if (object->out.record_number == NULL) {
		py_record_number = Py_None;
		Py_INCREF(py_record_number);
	} else {
		py_record_number = PyLong_FromUnsignedLongLong((uint32_t)*object->out.record_number);
	}
	return py_record_number;
}

static int py_eventlog_ReportEventAndSourceW_out_set_record_number(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_ReportEventAndSourceW *object = (struct eventlog_ReportEventAndSourceW *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->out.record_number));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->out.record_number");
		return -1;
	}
	if (value == Py_None) {
		object->out.record_number = NULL;
	} else {
		object->out.record_number = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->out.record_number);
		if (object->out.record_number == NULL) {
			PyErr_NoMemory();
			return -1;
		}
		{
			const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(*object->out.record_number));
			if (PyLong_Check(value)) {
				unsigned long long test_var;
				test_var = PyLong_AsUnsignedLongLong(value);
				if (PyErr_Occurred() != NULL) {
					return -1;
				}
				if (test_var > uint_max) {
					PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
					  PyLong_Type.tp_name, uint_max, test_var);
					return -1;
				}
				*object->out.record_number = test_var;
			} else {
				PyErr_Format(PyExc_TypeError, "Expected type %s",\
				  PyLong_Type.tp_name);
				return -1;
			}
		}
	}
	return 0;
}

static PyObject *py_eventlog_ReportEventAndSourceW_in_get_time_written(PyObject *obj, void *closure)
{
	struct eventlog_ReportEventAndSourceW *object = (struct eventlog_ReportEventAndSourceW *)pytalloc_get_ptr(obj);
	PyObject *py_time_written;
	if (object->in.time_written == NULL) {
		Py_RETURN_NONE;
	}
	if (object->in.time_written == NULL) {
		py_time_written = Py_None;
		Py_INCREF(py_time_written);
	} else {
		py_time_written = PyLong_FromLong(*object->in.time_written);
	}
	return py_time_written;
}

static int py_eventlog_ReportEventAndSourceW_in_set_time_written(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_ReportEventAndSourceW *object = (struct eventlog_ReportEventAndSourceW *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.time_written));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.time_written");
		return -1;
	}
	if (value == Py_None) {
		object->in.time_written = NULL;
	} else {
		object->in.time_written = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->in.time_written);
		if (object->in.time_written == NULL) {
			PyErr_NoMemory();
			return -1;
		}
		{
			const long long int_max = ndr_sizeof2intmax(sizeof(*object->in.time_written));
			const long long int_min = -int_max - 1;
			if (PyLong_Check(value)) {
				long long test_var;
				test_var = PyLong_AsLongLong(value);
				if (PyErr_Occurred() != NULL) {
					return -1;
				}
				if (test_var < int_min || test_var > int_max) {
					PyErr_Format(PyExc_OverflowError, "Expected type %s within range %lld - %lld, got %lld",\
					  PyLong_Type.tp_name, int_min, int_max, test_var);
					return -1;
				}
				*object->in.time_written = test_var;
			} else {
				PyErr_Format(PyExc_TypeError, "Expected type %s",\
				  PyLong_Type.tp_name);
				return -1;
			}
		}
	}
	return 0;
}

static PyObject *py_eventlog_ReportEventAndSourceW_out_get_time_written(PyObject *obj, void *closure)
{
	struct eventlog_ReportEventAndSourceW *object = (struct eventlog_ReportEventAndSourceW *)pytalloc_get_ptr(obj);
	PyObject *py_time_written;
	if (object->out.time_written == NULL) {
		Py_RETURN_NONE;
	}
	if (object->out.time_written == NULL) {
		py_time_written = Py_None;
		Py_INCREF(py_time_written);
	} else {
		py_time_written = PyLong_FromLong(*object->out.time_written);
	}
	return py_time_written;
}

static int py_eventlog_ReportEventAndSourceW_out_set_time_written(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_ReportEventAndSourceW *object = (struct eventlog_ReportEventAndSourceW *)pytalloc_get_ptr(py_obj);
	talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->out.time_written));
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->out.time_written");
		return -1;
	}
	if (value == Py_None) {
		object->out.time_written = NULL;
	} else {
		object->out.time_written = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->out.time_written);
		if (object->out.time_written == NULL) {
			PyErr_NoMemory();
			return -1;
		}
		{
			const long long int_max = ndr_sizeof2intmax(sizeof(*object->out.time_written));
			const long long int_min = -int_max - 1;
			if (PyLong_Check(value)) {
				long long test_var;
				test_var = PyLong_AsLongLong(value);
				if (PyErr_Occurred() != NULL) {
					return -1;
				}
				if (test_var < int_min || test_var > int_max) {
					PyErr_Format(PyExc_OverflowError, "Expected type %s within range %lld - %lld, got %lld",\
					  PyLong_Type.tp_name, int_min, int_max, test_var);
					return -1;
				}
				*object->out.time_written = test_var;
			} else {
				PyErr_Format(PyExc_TypeError, "Expected type %s",\
				  PyLong_Type.tp_name);
				return -1;
			}
		}
	}
	return 0;
}

static PyObject *py_eventlog_ReportEventAndSourceW_get_result(PyObject *obj, void *closure)
{
	struct eventlog_ReportEventAndSourceW *object = (struct eventlog_ReportEventAndSourceW *)pytalloc_get_ptr(obj);
	PyObject *py_result;
	py_result = PyErr_FromNTSTATUS(object->out.result);
	return py_result;
}

static int py_eventlog_ReportEventAndSourceW_set_result(PyObject *py_obj, PyObject *value, void *closure)
{
	struct eventlog_ReportEventAndSourceW *object = (struct eventlog_ReportEventAndSourceW *)pytalloc_get_ptr(py_obj);
	if (value == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->out.result");
		return -1;
	}
	object->out.result = NT_STATUS(PyLong_AsLong(value));
	return 0;
}

static PyGetSetDef py_eventlog_ReportEventAndSourceW_getsetters[] = {
	{
		.name = discard_const_p(char, "in_handle"),
		.get = py_eventlog_ReportEventAndSourceW_in_get_handle,
		.set = py_eventlog_ReportEventAndSourceW_in_set_handle,
		.doc = discard_const_p(char, "PIDL-generated element of base type policy_handle")
	},
	{
		.name = discard_const_p(char, "in_timestamp"),
		.get = py_eventlog_ReportEventAndSourceW_in_get_timestamp,
		.set = py_eventlog_ReportEventAndSourceW_in_set_timestamp,
		.doc = discard_const_p(char, "PIDL-generated element of base type time_t")
	},
	{
		.name = discard_const_p(char, "in_event_type"),
		.get = py_eventlog_ReportEventAndSourceW_in_get_event_type,
		.set = py_eventlog_ReportEventAndSourceW_in_set_event_type,
		.doc = discard_const_p(char, "PIDL-generated element of base type eventlogEventTypes")
	},
	{
		.name = discard_const_p(char, "in_event_category"),
		.get = py_eventlog_ReportEventAndSourceW_in_get_event_category,
		.set = py_eventlog_ReportEventAndSourceW_in_set_event_category,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint16")
	},
	{
		.name = discard_const_p(char, "in_event_id"),
		.get = py_eventlog_ReportEventAndSourceW_in_get_event_id,
		.set = py_eventlog_ReportEventAndSourceW_in_set_event_id,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "in_sourcename"),
		.get = py_eventlog_ReportEventAndSourceW_in_get_sourcename,
		.set = py_eventlog_ReportEventAndSourceW_in_set_sourcename,
		.doc = discard_const_p(char, "PIDL-generated element of base type lsa_String")
	},
	{
		.name = discard_const_p(char, "in_num_of_strings"),
		.get = py_eventlog_ReportEventAndSourceW_in_get_num_of_strings,
		.set = py_eventlog_ReportEventAndSourceW_in_set_num_of_strings,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint16")
	},
	{
		.name = discard_const_p(char, "in_data_size"),
		.get = py_eventlog_ReportEventAndSourceW_in_get_data_size,
		.set = py_eventlog_ReportEventAndSourceW_in_set_data_size,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "in_servername"),
		.get = py_eventlog_ReportEventAndSourceW_in_get_servername,
		.set = py_eventlog_ReportEventAndSourceW_in_set_servername,
		.doc = discard_const_p(char, "PIDL-generated element of base type lsa_String")
	},
	{
		.name = discard_const_p(char, "in_user_sid"),
		.get = py_eventlog_ReportEventAndSourceW_in_get_user_sid,
		.set = py_eventlog_ReportEventAndSourceW_in_set_user_sid,
		.doc = discard_const_p(char, "PIDL-generated element of base type dom_sid")
	},
	{
		.name = discard_const_p(char, "in_strings"),
		.get = py_eventlog_ReportEventAndSourceW_in_get_strings,
		.set = py_eventlog_ReportEventAndSourceW_in_set_strings,
		.doc = discard_const_p(char, "PIDL-generated element of base type lsa_String")
	},
	{
		.name = discard_const_p(char, "in_data"),
		.get = py_eventlog_ReportEventAndSourceW_in_get_data,
		.set = py_eventlog_ReportEventAndSourceW_in_set_data,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint8")
	},
	{
		.name = discard_const_p(char, "in_flags"),
		.get = py_eventlog_ReportEventAndSourceW_in_get_flags,
		.set = py_eventlog_ReportEventAndSourceW_in_set_flags,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint16")
	},
	{
		.name = discard_const_p(char, "in_record_number"),
		.get = py_eventlog_ReportEventAndSourceW_in_get_record_number,
		.set = py_eventlog_ReportEventAndSourceW_in_set_record_number,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "out_record_number"),
		.get = py_eventlog_ReportEventAndSourceW_out_get_record_number,
		.set = py_eventlog_ReportEventAndSourceW_out_set_record_number,
		.doc = discard_const_p(char, "PIDL-generated element of base type uint32")
	},
	{
		.name = discard_const_p(char, "in_time_written"),
		.get = py_eventlog_ReportEventAndSourceW_in_get_time_written,
		.set = py_eventlog_ReportEventAndSourceW_in_set_time_written,
		.doc = discard_const_p(char, "PIDL-generated element of base type time_t")
	},
	{
		.name = discard_const_p(char, "out_time_written"),
		.get = py_eventlog_ReportEventAndSourceW_out_get_time_written,
		.set = py_eventlog_ReportEventAndSourceW_out_set_time_written,
		.doc = discard_const_p(char, "PIDL-generated element of base type time_t")
	},
	{
		.name = discard_const_p(char, "result"),
		.get = py_eventlog_ReportEventAndSourceW_get_result,
		.set = py_eventlog_ReportEventAndSourceW_set_result,
		.doc = discard_const_p(char, "PIDL-generated element of type NTSTATUS")
	},
	{ .name = NULL }
};

static PyObject *py_eventlog_ReportEventAndSourceW_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	PyObject *self = pytalloc_new(struct eventlog_ReportEventAndSourceW, type);
	struct eventlog_ReportEventAndSourceW *_self = (struct eventlog_ReportEventAndSourceW *)pytalloc_get_ptr(self);
	TALLOC_CTX *mem_ctx = pytalloc_get_mem_ctx(self);
	_self->in.handle = talloc_zero(mem_ctx, struct policy_handle);
	_self->in.sourcename = talloc_zero(mem_ctx, struct lsa_String);
	_self->in.servername = talloc_zero(mem_ctx, struct lsa_String);
	return self;
}

static PyObject *py_eventlog_ReportEventAndSourceW_ndr_opnum(PyTypeObject *type, PyObject *Py_UNUSED(ignored))
{


	return PyLong_FromLong(24);
}

static PyObject *py_eventlog_ReportEventAndSourceW_ndr_pack(PyObject *py_obj, int ndr_inout_flags, uint32_t ndr_push_flags)
{
	const struct ndr_interface_call *call = NULL;
	struct eventlog_ReportEventAndSourceW *object = (struct eventlog_ReportEventAndSourceW *)pytalloc_get_ptr(py_obj);
	PyObject *ret = NULL;
	struct ndr_push *push = NULL;
	DATA_BLOB blob;
	enum ndr_err_code err;

	if (ndr_table_eventlog.num_calls < 25) {
		PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_eventlog_ReportEventAndSourceW_ndr_pack");
		return NULL;
	}
	call = &ndr_table_eventlog.calls[24];

	push = ndr_push_init_ctx(pytalloc_get_mem_ctx(py_obj));
	if (push == NULL) {
		PyErr_SetNdrError(NDR_ERR_ALLOC);
		return NULL;
	}

	push->flags |= ndr_push_flags;

	err = call->ndr_push(push, ndr_inout_flags, object);
	if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
		TALLOC_FREE(push);
		PyErr_SetNdrError(err);
		return NULL;
	}
	blob = ndr_push_blob(push);
	ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
	TALLOC_FREE(push);
	return ret;
}

static PyObject *py_eventlog_ReportEventAndSourceW_ndr_pack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	const char * const kwnames[] = { "bigendian", "ndr64", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_push_flags = 0;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_in__",
		discard_const_p(char *, kwnames),
		&bigendian_obj,
		&ndr64_obj)) {
		return NULL;
	}

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_NDR64;
	}

	return py_eventlog_ReportEventAndSourceW_ndr_pack(py_obj, NDR_IN, ndr_push_flags);
}

static PyObject *py_eventlog_ReportEventAndSourceW_ndr_pack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	const char * const kwnames[] = { "bigendian", "ndr64", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_push_flags = 0;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_out__",
		discard_const_p(char *, kwnames),
		&bigendian_obj,
		&ndr64_obj)) {
		return NULL;
	}

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_push_flags |= LIBNDR_FLAG_NDR64;
	}

	return py_eventlog_ReportEventAndSourceW_ndr_pack(py_obj, NDR_OUT, ndr_push_flags);
}

static PyObject *py_eventlog_ReportEventAndSourceW_ndr_unpack(PyObject *py_obj, const DATA_BLOB *blob, int ndr_inout_flags, uint32_t ndr_pull_flags, bool allow_remaining)
{
	const struct ndr_interface_call *call = NULL;
	struct eventlog_ReportEventAndSourceW *object = (struct eventlog_ReportEventAndSourceW *)pytalloc_get_ptr(py_obj);
	struct ndr_pull *pull = NULL;
	enum ndr_err_code err;

	if (ndr_table_eventlog.num_calls < 25) {
		PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_eventlog_ReportEventAndSourceW_ndr_unpack");
		return NULL;
	}
	call = &ndr_table_eventlog.calls[24];

	pull = ndr_pull_init_blob(blob, object);
	if (pull == NULL) {
		PyErr_SetNdrError(NDR_ERR_ALLOC);
		return NULL;
	}

	pull->flags |= ndr_pull_flags;

	err = call->ndr_pull(pull, ndr_inout_flags, object);
	if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
		TALLOC_FREE(pull);
		PyErr_SetNdrError(err);
		return NULL;
	}
	if (!allow_remaining) {
		uint32_t highest_ofs;

		if (pull->offset > pull->relative_highest_offset) {
			highest_ofs = pull->offset;
		} else {
			highest_ofs = pull->relative_highest_offset;
		}
		if (highest_ofs < pull->data_size) {
			err = ndr_pull_error(pull, NDR_ERR_UNREAD_BYTES,
				"not all bytes consumed ofs[%u] size[%u]",
				highest_ofs, pull->data_size);
			TALLOC_FREE(pull);
			PyErr_SetNdrError(err);
			return NULL;
		}
	}

	TALLOC_FREE(pull);
	Py_RETURN_NONE;
}

static PyObject *py_eventlog_ReportEventAndSourceW_ndr_unpack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	DATA_BLOB blob;
	Py_ssize_t blob_length = 0;
	const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
	PyObject *allow_remaining_obj = NULL;
	bool allow_remaining = false;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_in__",
		discard_const_p(char *, kwnames),
		&blob.data, &blob_length,
		&bigendian_obj,
		&ndr64_obj,
		&allow_remaining_obj)) {
		return NULL;
	}
	blob.length = blob_length;

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_NDR64;
	}

	if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
		allow_remaining = true;
	}

	return py_eventlog_ReportEventAndSourceW_ndr_unpack(py_obj, &blob, NDR_IN, ndr_pull_flags, allow_remaining);
}

static PyObject *py_eventlog_ReportEventAndSourceW_ndr_unpack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
	DATA_BLOB blob;
	Py_ssize_t blob_length = 0;
	const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
	PyObject *bigendian_obj = NULL;
	PyObject *ndr64_obj = NULL;
	uint32_t ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
	PyObject *allow_remaining_obj = NULL;
	bool allow_remaining = false;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_out__",
		discard_const_p(char *, kwnames),
		&blob.data, &blob_length,
		&bigendian_obj,
		&ndr64_obj,
		&allow_remaining_obj)) {
		return NULL;
	}
	blob.length = blob_length;

	if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
	}
	if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
		ndr_pull_flags |= LIBNDR_FLAG_NDR64;
	}

	if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
		allow_remaining = true;
	}

	return py_eventlog_ReportEventAndSourceW_ndr_unpack(py_obj, &blob, NDR_OUT, ndr_pull_flags, allow_remaining);
}

static PyObject *py_eventlog_ReportEventAndSourceW_ndr_print(PyObject *py_obj, const char *name, int ndr_inout_flags)
{
	const struct ndr_interface_call *call = NULL;
	struct eventlog_ReportEventAndSourceW *object = (struct eventlog_ReportEventAndSourceW *)pytalloc_get_ptr(py_obj);
	PyObject *ret;
	char *retstr;

	if (ndr_table_eventlog.num_calls < 25) {
		PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_eventlog_ReportEventAndSourceW_ndr_print");
		return NULL;
	}
	call = &ndr_table_eventlog.calls[24];

	retstr = ndr_print_function_string(pytalloc_get_mem_ctx(py_obj), call->ndr_print, name, ndr_inout_flags, object);
	ret = PyUnicode_FromString(retstr);
	TALLOC_FREE(retstr);

	return ret;
}

static PyObject *py_eventlog_ReportEventAndSourceW_ndr_print_in(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
{
	return py_eventlog_ReportEventAndSourceW_ndr_print(py_obj, "eventlog_ReportEventAndSourceW_in", NDR_IN);
}

static PyObject *py_eventlog_ReportEventAndSourceW_ndr_print_out(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
{
	return py_eventlog_ReportEventAndSourceW_ndr_print(py_obj, "eventlog_ReportEventAndSourceW_out", NDR_OUT);
}

static PyMethodDef py_eventlog_ReportEventAndSourceW_methods[] = {
	{ "opnum", (PyCFunction)py_eventlog_ReportEventAndSourceW_ndr_opnum, METH_NOARGS|METH_CLASS,
		"eventlog.ReportEventAndSourceW.opnum() -> 24 (0x18) " },
	{ "__ndr_pack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_ReportEventAndSourceW_ndr_pack_in), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_pack_in(object, bigendian=False, ndr64=False) -> blob\nNDR pack input" },
	{ "__ndr_pack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_ReportEventAndSourceW_ndr_pack_out), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_pack_out(object, bigendian=False, ndr64=False) -> blob\nNDR pack output" },
	{ "__ndr_unpack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_ReportEventAndSourceW_ndr_unpack_in), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_unpack_in(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack input" },
	{ "__ndr_unpack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_eventlog_ReportEventAndSourceW_ndr_unpack_out), METH_VARARGS|METH_KEYWORDS,
		"S.ndr_unpack_out(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack output" },
	{ "__ndr_print_in__", (PyCFunction)py_eventlog_ReportEventAndSourceW_ndr_print_in, METH_NOARGS, "S.ndr_print_in(object) -> None\nNDR print input" },
	{ "__ndr_print_out__", (PyCFunction)py_eventlog_ReportEventAndSourceW_ndr_print_out, METH_NOARGS, "S.ndr_print_out(object) -> None\nNDR print output" },
	{ NULL, NULL, 0, NULL }
};


static PyTypeObject eventlog_ReportEventAndSourceW_Type = {
	PyVarObject_HEAD_INIT(NULL, 0)
	.tp_name = "eventlog.ReportEventAndSourceW",
	.tp_getset = py_eventlog_ReportEventAndSourceW_getsetters,
	.tp_methods = py_eventlog_ReportEventAndSourceW_methods,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_new = py_eventlog_ReportEventAndSourceW_new,
};

static bool pack_py_eventlog_ReportEventAndSourceW_args_in(PyObject *args, PyObject *kwargs, struct eventlog_ReportEventAndSourceW *r)
{
	PyObject *py_handle;
	PyObject *py_timestamp;
	PyObject *py_event_type;
	PyObject *py_event_category;
	PyObject *py_event_id;
	PyObject *py_sourcename;
	PyObject *py_servername;
	PyObject *py_user_sid;
	PyObject *py_strings;
	PyObject *py_data;
	PyObject *py_flags;
	PyObject *py_record_number;
	PyObject *py_time_written;
	const char *kwnames[] = {
		"handle", "timestamp", "event_type", "event_category", "event_id", "sourcename", "servername", "user_sid", "strings", "data", "flags", "record_number", "time_written", NULL
	};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOOOOOOO:eventlog_ReportEventAndSourceW", discard_const_p(char *, kwnames), &py_handle, &py_timestamp, &py_event_type, &py_event_category, &py_event_id, &py_sourcename, &py_servername, &py_user_sid, &py_strings, &py_data, &py_flags, &py_record_number, &py_time_written)) {
		return false;
	}

	if (py_handle == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.handle");
		return false;
	}
	r->in.handle = talloc_ptrtype(r, r->in.handle);
	if (r->in.handle == NULL) {
		PyErr_NoMemory();
		return false;
	}
	PY_CHECK_TYPE(policy_handle_Type, py_handle, return false;);
	if (talloc_reference(r, pytalloc_get_mem_ctx(py_handle)) == NULL) {
		PyErr_NoMemory();
		return false;
	}
	r->in.handle = (struct policy_handle *)pytalloc_get_ptr(py_handle);
	if (py_timestamp == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.timestamp");
		return false;
	}
	{
		const long long int_max = ndr_sizeof2intmax(sizeof(r->in.timestamp));
		const long long int_min = -int_max - 1;
		if (PyLong_Check(py_timestamp)) {
			long long test_var;
			test_var = PyLong_AsLongLong(py_timestamp);
			if (PyErr_Occurred() != NULL) {
				return false;
			}
			if (test_var < int_min || test_var > int_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range %lld - %lld, got %lld",\
				  PyLong_Type.tp_name, int_min, int_max, test_var);
				return false;
			}
			r->in.timestamp = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return false;
		}
	}
	if (py_event_type == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.event_type");
		return false;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.event_type));
		if (PyLong_Check(py_event_type)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(py_event_type);
			if (PyErr_Occurred() != NULL) {
				return false;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return false;
			}
			r->in.event_type = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return false;
		}
	}
	if (py_event_category == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.event_category");
		return false;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.event_category));
		if (PyLong_Check(py_event_category)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(py_event_category);
			if (PyErr_Occurred() != NULL) {
				return false;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return false;
			}
			r->in.event_category = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return false;
		}
	}
	if (py_event_id == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.event_id");
		return false;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.event_id));
		if (PyLong_Check(py_event_id)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(py_event_id);
			if (PyErr_Occurred() != NULL) {
				return false;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return false;
			}
			r->in.event_id = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return false;
		}
	}
	if (py_sourcename == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.sourcename");
		return false;
	}
	r->in.sourcename = talloc_ptrtype(r, r->in.sourcename);
	if (r->in.sourcename == NULL) {
		PyErr_NoMemory();
		return false;
	}
	PY_CHECK_TYPE(lsa_String_Type, py_sourcename, return false;);
	if (talloc_reference(r, pytalloc_get_mem_ctx(py_sourcename)) == NULL) {
		PyErr_NoMemory();
		return false;
	}
	r->in.sourcename = (struct lsa_String *)pytalloc_get_ptr(py_sourcename);
	PY_CHECK_TYPE(&PyList_Type, py_strings, return false;);
	r->in.num_of_strings = PyList_GET_SIZE(py_strings);
	PY_CHECK_TYPE(&PyList_Type, py_data, return false;);
	r->in.data_size = PyList_GET_SIZE(py_data);
	if (py_servername == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.servername");
		return false;
	}
	r->in.servername = talloc_ptrtype(r, r->in.servername);
	if (r->in.servername == NULL) {
		PyErr_NoMemory();
		return false;
	}
	PY_CHECK_TYPE(lsa_String_Type, py_servername, return false;);
	if (talloc_reference(r, pytalloc_get_mem_ctx(py_servername)) == NULL) {
		PyErr_NoMemory();
		return false;
	}
	r->in.servername = (struct lsa_String *)pytalloc_get_ptr(py_servername);
	if (py_user_sid == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.user_sid");
		return false;
	}
	if (py_user_sid == Py_None) {
		r->in.user_sid = NULL;
	} else {
		r->in.user_sid = NULL;
		PY_CHECK_TYPE(dom_sid_Type, py_user_sid, return false;);
		if (talloc_reference(r, pytalloc_get_mem_ctx(py_user_sid)) == NULL) {
			PyErr_NoMemory();
			return false;
		}
		r->in.user_sid = (struct dom_sid *)pytalloc_get_ptr(py_user_sid);
	}
	if (py_strings == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.strings");
		return false;
	}
	if (py_strings == Py_None) {
		r->in.strings = NULL;
	} else {
		r->in.strings = NULL;
		PY_CHECK_TYPE(&PyList_Type, py_strings, return false;);
		{
			int strings_cntr_1;
			r->in.strings = talloc_array_ptrtype(r, r->in.strings, PyList_GET_SIZE(py_strings));
			if (!r->in.strings) { return false;; }
			talloc_set_name_const(r->in.strings, "ARRAY: r->in.strings");
			for (strings_cntr_1 = 0; strings_cntr_1 < PyList_GET_SIZE(py_strings); strings_cntr_1++) {
				if (PyList_GET_ITEM(py_strings, strings_cntr_1) == NULL) {
					PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.strings[strings_cntr_1]");
					return false;
				}
				if (PyList_GET_ITEM(py_strings, strings_cntr_1) == Py_None) {
					r->in.strings[strings_cntr_1] = NULL;
				} else {
					r->in.strings[strings_cntr_1] = NULL;
					PY_CHECK_TYPE(lsa_String_Type, PyList_GET_ITEM(py_strings, strings_cntr_1), return false;);
					if (talloc_reference(r->in.strings, pytalloc_get_mem_ctx(PyList_GET_ITEM(py_strings, strings_cntr_1))) == NULL) {
						PyErr_NoMemory();
						return false;
					}
					r->in.strings[strings_cntr_1] = (struct lsa_String *)pytalloc_get_ptr(PyList_GET_ITEM(py_strings, strings_cntr_1));
				}
			}
		}
	}
	if (py_data == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.data");
		return false;
	}
	if (py_data == Py_None) {
		r->in.data = NULL;
	} else {
		r->in.data = NULL;
		PY_CHECK_TYPE(&PyList_Type, py_data, return false;);
		{
			int data_cntr_1;
			r->in.data = talloc_array_ptrtype(r, r->in.data, PyList_GET_SIZE(py_data));
			if (!r->in.data) { return false;; }
			talloc_set_name_const(r->in.data, "ARRAY: r->in.data");
			for (data_cntr_1 = 0; data_cntr_1 < PyList_GET_SIZE(py_data); data_cntr_1++) {
				if (PyList_GET_ITEM(py_data, data_cntr_1) == NULL) {
					PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.data[data_cntr_1]");
					return false;
				}
				{
					const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.data[data_cntr_1]));
					if (PyLong_Check(PyList_GET_ITEM(py_data, data_cntr_1))) {
						unsigned long long test_var;
						test_var = PyLong_AsUnsignedLongLong(PyList_GET_ITEM(py_data, data_cntr_1));
						if (PyErr_Occurred() != NULL) {
							return false;
						}
						if (test_var > uint_max) {
							PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
							  PyLong_Type.tp_name, uint_max, test_var);
							return false;
						}
						r->in.data[data_cntr_1] = test_var;
					} else {
						PyErr_Format(PyExc_TypeError, "Expected type %s",\
						  PyLong_Type.tp_name);
						return false;
					}
				}
			}
		}
	}
	if (py_flags == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.flags");
		return false;
	}
	{
		const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.flags));
		if (PyLong_Check(py_flags)) {
			unsigned long long test_var;
			test_var = PyLong_AsUnsignedLongLong(py_flags);
			if (PyErr_Occurred() != NULL) {
				return false;
			}
			if (test_var > uint_max) {
				PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
				  PyLong_Type.tp_name, uint_max, test_var);
				return false;
			}
			r->in.flags = test_var;
		} else {
			PyErr_Format(PyExc_TypeError, "Expected type %s",\
			  PyLong_Type.tp_name);
			return false;
		}
	}
	if (py_record_number == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.record_number");
		return false;
	}
	if (py_record_number == Py_None) {
		r->in.record_number = NULL;
	} else {
		r->in.record_number = talloc_ptrtype(r, r->in.record_number);
		if (r->in.record_number == NULL) {
			PyErr_NoMemory();
			return false;
		}
		{
			const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(*r->in.record_number));
			if (PyLong_Check(py_record_number)) {
				unsigned long long test_var;
				test_var = PyLong_AsUnsignedLongLong(py_record_number);
				if (PyErr_Occurred() != NULL) {
					return false;
				}
				if (test_var > uint_max) {
					PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\
					  PyLong_Type.tp_name, uint_max, test_var);
					return false;
				}
				*r->in.record_number = test_var;
			} else {
				PyErr_Format(PyExc_TypeError, "Expected type %s",\
				  PyLong_Type.tp_name);
				return false;
			}
		}
	}
	if (py_time_written == NULL) {
		PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.time_written");
		return false;
	}
	if (py_time_written == Py_None) {
		r->in.time_written = NULL;
	} else {
		r->in.time_written = talloc_ptrtype(r, r->in.time_written);
		if (r->in.time_written == NULL) {
			PyErr_NoMemory();
			return false;
		}
		{
			const long long int_max = ndr_sizeof2intmax(sizeof(*r->in.time_written));
			const long long int_min = -int_max - 1;
			if (PyLong_Check(py_time_written)) {
				long long test_var;
				test_var = PyLong_AsLongLong(py_time_written);
				if (PyErr_Occurred() != NULL) {
					return false;
				}
				if (test_var < int_min || test_var > int_max) {
					PyErr_Format(PyExc_OverflowError, "Expected type %s within range %lld - %lld, got %lld",\
					  PyLong_Type.tp_name, int_min, int_max, test_var);
					return false;
				}
				*r->in.time_written = test_var;
			} else {
				PyErr_Format(PyExc_TypeError, "Expected type %s",\
				  PyLong_Type.tp_name);
				return false;
			}
		}
	}
	return true;
}

static PyObject *unpack_py_eventlog_ReportEventAndSourceW_args_out(struct eventlog_ReportEventAndSourceW *r)
{
	PyObject *result;
	PyObject *py_record_number;
	PyObject *py_time_written;
	result = PyTuple_New(2);
	if (r->out.record_number == NULL) {
		py_record_number = Py_None;
		Py_INCREF(py_record_number);
	} else {
		py_record_number = PyLong_FromUnsignedLongLong((uint32_t)*r->out.record_number);
	}
	PyTuple_SetItem(result, 0, py_record_number);
	if (r->out.time_written == NULL) {
		py_time_written = Py_None;
		Py_INCREF(py_time_written);
	} else {
		py_time_written = PyLong_FromLong(*r->out.time_written);
	}
	PyTuple_SetItem(result, 1, py_time_written);
	if (NT_STATUS_IS_ERR(r->out.result)) {
		PyErr_SetNTSTATUS(r->out.result);
		return NULL;
	}

	return result;
}

const struct PyNdrRpcMethodDef py_ndr_eventlog_methods[] = {
	{ "ClearEventLogW", "S.ClearEventLogW(handle, backupfile) -> None", (py_dcerpc_call_fn)dcerpc_eventlog_ClearEventLogW_r, (py_data_pack_fn)pack_py_eventlog_ClearEventLogW_args_in, (py_data_unpack_fn)unpack_py_eventlog_ClearEventLogW_args_out, 0, &ndr_table_eventlog },
	{ "BackupEventLogW", "S.BackupEventLogW(handle, backup_filename) -> None", (py_dcerpc_call_fn)dcerpc_eventlog_BackupEventLogW_r, (py_data_pack_fn)pack_py_eventlog_BackupEventLogW_args_in, (py_data_unpack_fn)unpack_py_eventlog_BackupEventLogW_args_out, 1, &ndr_table_eventlog },
	{ "CloseEventLog", "S.CloseEventLog(handle) -> handle", (py_dcerpc_call_fn)dcerpc_eventlog_CloseEventLog_r, (py_data_pack_fn)pack_py_eventlog_CloseEventLog_args_in, (py_data_unpack_fn)unpack_py_eventlog_CloseEventLog_args_out, 2, &ndr_table_eventlog },
	{ "DeregisterEventSource", "S.DeregisterEventSource(handle) -> handle", (py_dcerpc_call_fn)dcerpc_eventlog_DeregisterEventSource_r, (py_data_pack_fn)pack_py_eventlog_DeregisterEventSource_args_in, (py_data_unpack_fn)unpack_py_eventlog_DeregisterEventSource_args_out, 3, &ndr_table_eventlog },
	{ "GetNumRecords", "S.GetNumRecords(handle) -> number", (py_dcerpc_call_fn)dcerpc_eventlog_GetNumRecords_r, (py_data_pack_fn)pack_py_eventlog_GetNumRecords_args_in, (py_data_unpack_fn)unpack_py_eventlog_GetNumRecords_args_out, 4, &ndr_table_eventlog },
	{ "GetOldestRecord", "S.GetOldestRecord(handle) -> oldest_entry", (py_dcerpc_call_fn)dcerpc_eventlog_GetOldestRecord_r, (py_data_pack_fn)pack_py_eventlog_GetOldestRecord_args_in, (py_data_unpack_fn)unpack_py_eventlog_GetOldestRecord_args_out, 5, &ndr_table_eventlog },
	{ "OpenEventLogW", "S.OpenEventLogW(unknown0, logname, servername, major_version, minor_version) -> handle", (py_dcerpc_call_fn)dcerpc_eventlog_OpenEventLogW_r, (py_data_pack_fn)pack_py_eventlog_OpenEventLogW_args_in, (py_data_unpack_fn)unpack_py_eventlog_OpenEventLogW_args_out, 7, &ndr_table_eventlog },
	{ "RegisterEventSourceW", "S.RegisterEventSourceW(unknown0, module_name, reg_module_name, major_version, minor_version) -> log_handle", (py_dcerpc_call_fn)dcerpc_eventlog_RegisterEventSourceW_r, (py_data_pack_fn)pack_py_eventlog_RegisterEventSourceW_args_in, (py_data_unpack_fn)unpack_py_eventlog_RegisterEventSourceW_args_out, 8, &ndr_table_eventlog },
	{ "OpenBackupEventLogW", "S.OpenBackupEventLogW(unknown0, backup_logname, major_version, minor_version) -> handle", (py_dcerpc_call_fn)dcerpc_eventlog_OpenBackupEventLogW_r, (py_data_pack_fn)pack_py_eventlog_OpenBackupEventLogW_args_in, (py_data_unpack_fn)unpack_py_eventlog_OpenBackupEventLogW_args_out, 9, &ndr_table_eventlog },
	{ "ReadEventLogW", "S.ReadEventLogW(handle, flags, offset, number_of_bytes) -> (data, sent_size, real_size)", (py_dcerpc_call_fn)dcerpc_eventlog_ReadEventLogW_r, (py_data_pack_fn)pack_py_eventlog_ReadEventLogW_args_in, (py_data_unpack_fn)unpack_py_eventlog_ReadEventLogW_args_out, 10, &ndr_table_eventlog },
	{ "ReportEventW", "S.ReportEventW(handle, timestamp, event_type, event_category, event_id, servername, user_sid, strings, data, flags, record_number, time_written) -> (record_number, time_written)", (py_dcerpc_call_fn)dcerpc_eventlog_ReportEventW_r, (py_data_pack_fn)pack_py_eventlog_ReportEventW_args_in, (py_data_unpack_fn)unpack_py_eventlog_ReportEventW_args_out, 11, &ndr_table_eventlog },
	{ "GetLogInformation", "S.GetLogInformation(handle, level, buf_size) -> (buffer, bytes_needed)", (py_dcerpc_call_fn)dcerpc_eventlog_GetLogInformation_r, (py_data_pack_fn)pack_py_eventlog_GetLogInformation_args_in, (py_data_unpack_fn)unpack_py_eventlog_GetLogInformation_args_out, 22, &ndr_table_eventlog },
	{ "FlushEventLog", "S.FlushEventLog(handle) -> None", (py_dcerpc_call_fn)dcerpc_eventlog_FlushEventLog_r, (py_data_pack_fn)pack_py_eventlog_FlushEventLog_args_in, (py_data_unpack_fn)unpack_py_eventlog_FlushEventLog_args_out, 23, &ndr_table_eventlog },
	{ "ReportEventAndSourceW", "S.ReportEventAndSourceW(handle, timestamp, event_type, event_category, event_id, sourcename, servername, user_sid, strings, data, flags, record_number, time_written) -> (record_number, time_written)", (py_dcerpc_call_fn)dcerpc_eventlog_ReportEventAndSourceW_r, (py_data_pack_fn)pack_py_eventlog_ReportEventAndSourceW_args_in, (py_data_unpack_fn)unpack_py_eventlog_ReportEventAndSourceW_args_out, 24, &ndr_table_eventlog },
	{0}
};

static PyObject *interface_eventlog_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return py_dcerpc_interface_init_helper(type, args, kwargs, &ndr_table_eventlog);
}

#define PY_DOC_EVENTLOG "Event Logger"
static PyTypeObject eventlog_InterfaceType = {
	PyVarObject_HEAD_INIT(NULL, 0)
	.tp_name = "eventlog.eventlog",
	.tp_basicsize = sizeof(dcerpc_InterfaceObject),
	.tp_doc = "eventlog(binding, lp_ctx=None, credentials=None) -> connection\n"
"\n"
"binding should be a DCE/RPC binding string (for example: ncacn_ip_tcp:127.0.0.1)\n"
"lp_ctx should be a path to a smb.conf file or a param.LoadParm object\n"
"credentials should be a credentials.Credentials object.\n\n"PY_DOC_EVENTLOG,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_new = interface_eventlog_new,
};

static PyObject *syntax_eventlog_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
	return py_dcerpc_syntax_init_helper(type, args, kwargs, &ndr_table_eventlog.syntax_id);
}

#define PY_DOC_EVENTLOG_SYNTAX "Event Logger"
static PyTypeObject eventlog_SyntaxType = {
	PyVarObject_HEAD_INIT(NULL, 0)
	.tp_name = "eventlog.eventlog_abstract_syntax",
	.tp_doc = "eventlog_abstract_syntax()\n"PY_DOC_EVENTLOG_SYNTAX,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
	.tp_new = syntax_eventlog_new,
};

static PyMethodDef eventlog_methods[] = {
	{ NULL, NULL, 0, NULL }
};

static struct PyModuleDef moduledef = {
	PyModuleDef_HEAD_INIT,
	.m_name = "eventlog",
	.m_doc = "eventlog DCE/RPC",
	.m_size = -1,
	.m_methods = eventlog_methods,
};
MODULE_INIT_FUNC(eventlog)
{
	PyObject *m = NULL;
	PyObject *dep_samba_dcerpc_lsa = NULL;
	PyObject *dep_samba_dcerpc_security = NULL;
	PyObject *dep_talloc = NULL;
	PyObject *dep_samba_dcerpc_misc = NULL;
	PyObject *dep_samba_dcerpc_base = NULL;

	dep_samba_dcerpc_lsa = PyImport_ImportModule("samba.dcerpc.lsa");
	if (dep_samba_dcerpc_lsa == NULL)
		goto out;

	dep_samba_dcerpc_security = PyImport_ImportModule("samba.dcerpc.security");
	if (dep_samba_dcerpc_security == NULL)
		goto out;

	dep_talloc = PyImport_ImportModule("talloc");
	if (dep_talloc == NULL)
		goto out;

	dep_samba_dcerpc_misc = PyImport_ImportModule("samba.dcerpc.misc");
	if (dep_samba_dcerpc_misc == NULL)
		goto out;

	dep_samba_dcerpc_base = PyImport_ImportModule("samba.dcerpc.base");
	if (dep_samba_dcerpc_base == NULL)
		goto out;

	BaseObject_Type = (PyTypeObject *)PyObject_GetAttrString(dep_talloc, "BaseObject");
	if (BaseObject_Type == NULL)
		goto out;

	dom_sid_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_security, "dom_sid");
	if (dom_sid_Type == NULL)
		goto out;

	policy_handle_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_misc, "policy_handle");
	if (policy_handle_Type == NULL)
		goto out;

	lsa_String_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_lsa, "String");
	if (lsa_String_Type == NULL)
		goto out;

	ClientConnection_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_base, "ClientConnection");
	if (ClientConnection_Type == NULL)
		goto out;

	ndr_syntax_id_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_misc, "ndr_syntax_id");
	if (ndr_syntax_id_Type == NULL)
		goto out;

	eventlog_OpenUnknown0_Type.tp_base = BaseObject_Type;
	eventlog_OpenUnknown0_Type.tp_basicsize = pytalloc_BaseObject_size();

	eventlog_Record_tdb_Type.tp_base = BaseObject_Type;
	eventlog_Record_tdb_Type.tp_basicsize = pytalloc_BaseObject_size();

	EVENTLOGHEADER_Type.tp_base = BaseObject_Type;
	EVENTLOGHEADER_Type.tp_basicsize = pytalloc_BaseObject_size();

	EVENTLOGRECORD_Type.tp_base = BaseObject_Type;
	EVENTLOGRECORD_Type.tp_basicsize = pytalloc_BaseObject_size();

	EVENTLOGEOF_Type.tp_base = BaseObject_Type;
	EVENTLOGEOF_Type.tp_basicsize = pytalloc_BaseObject_size();

	EVENTLOG_EVT_FILE_Type.tp_base = BaseObject_Type;
	EVENTLOG_EVT_FILE_Type.tp_basicsize = pytalloc_BaseObject_size();

	EVENTLOG_FULL_INFORMATION_Type.tp_base = BaseObject_Type;
	EVENTLOG_FULL_INFORMATION_Type.tp_basicsize = pytalloc_BaseObject_size();

	eventlog_ClearEventLogW_Type.tp_base = BaseObject_Type;
	eventlog_ClearEventLogW_Type.tp_basicsize = pytalloc_BaseObject_size();

	eventlog_BackupEventLogW_Type.tp_base = BaseObject_Type;
	eventlog_BackupEventLogW_Type.tp_basicsize = pytalloc_BaseObject_size();

	eventlog_CloseEventLog_Type.tp_base = BaseObject_Type;
	eventlog_CloseEventLog_Type.tp_basicsize = pytalloc_BaseObject_size();

	eventlog_DeregisterEventSource_Type.tp_base = BaseObject_Type;
	eventlog_DeregisterEventSource_Type.tp_basicsize = pytalloc_BaseObject_size();

	eventlog_GetNumRecords_Type.tp_base = BaseObject_Type;
	eventlog_GetNumRecords_Type.tp_basicsize = pytalloc_BaseObject_size();

	eventlog_GetOldestRecord_Type.tp_base = BaseObject_Type;
	eventlog_GetOldestRecord_Type.tp_basicsize = pytalloc_BaseObject_size();

	eventlog_OpenEventLogW_Type.tp_base = BaseObject_Type;
	eventlog_OpenEventLogW_Type.tp_basicsize = pytalloc_BaseObject_size();

	eventlog_RegisterEventSourceW_Type.tp_base = BaseObject_Type;
	eventlog_RegisterEventSourceW_Type.tp_basicsize = pytalloc_BaseObject_size();

	eventlog_OpenBackupEventLogW_Type.tp_base = BaseObject_Type;
	eventlog_OpenBackupEventLogW_Type.tp_basicsize = pytalloc_BaseObject_size();

	eventlog_ReadEventLogW_Type.tp_base = BaseObject_Type;
	eventlog_ReadEventLogW_Type.tp_basicsize = pytalloc_BaseObject_size();

	eventlog_ReportEventW_Type.tp_base = BaseObject_Type;
	eventlog_ReportEventW_Type.tp_basicsize = pytalloc_BaseObject_size();

	eventlog_GetLogInformation_Type.tp_base = BaseObject_Type;
	eventlog_GetLogInformation_Type.tp_basicsize = pytalloc_BaseObject_size();

	eventlog_FlushEventLog_Type.tp_base = BaseObject_Type;
	eventlog_FlushEventLog_Type.tp_basicsize = pytalloc_BaseObject_size();

	eventlog_ReportEventAndSourceW_Type.tp_base = BaseObject_Type;
	eventlog_ReportEventAndSourceW_Type.tp_basicsize = pytalloc_BaseObject_size();

	eventlog_InterfaceType.tp_base = ClientConnection_Type;

	eventlog_SyntaxType.tp_base = ndr_syntax_id_Type;
	eventlog_SyntaxType.tp_basicsize = pytalloc_BaseObject_size();

	if (PyType_Ready(&eventlog_OpenUnknown0_Type) < 0)
		goto out;
	if (PyType_Ready(&eventlog_Record_tdb_Type) < 0)
		goto out;
	if (PyType_Ready(&EVENTLOGHEADER_Type) < 0)
		goto out;
	if (PyType_Ready(&EVENTLOGRECORD_Type) < 0)
		goto out;
	if (PyType_Ready(&EVENTLOGEOF_Type) < 0)
		goto out;
	if (PyType_Ready(&EVENTLOG_EVT_FILE_Type) < 0)
		goto out;
	if (PyType_Ready(&EVENTLOG_FULL_INFORMATION_Type) < 0)
		goto out;
	if (PyType_Ready(&eventlog_ClearEventLogW_Type) < 0)
		goto out;
	if (PyType_Ready(&eventlog_BackupEventLogW_Type) < 0)
		goto out;
	if (PyType_Ready(&eventlog_CloseEventLog_Type) < 0)
		goto out;
	if (PyType_Ready(&eventlog_DeregisterEventSource_Type) < 0)
		goto out;
	if (PyType_Ready(&eventlog_GetNumRecords_Type) < 0)
		goto out;
	if (PyType_Ready(&eventlog_GetOldestRecord_Type) < 0)
		goto out;
	if (PyType_Ready(&eventlog_OpenEventLogW_Type) < 0)
		goto out;
	if (PyType_Ready(&eventlog_RegisterEventSourceW_Type) < 0)
		goto out;
	if (PyType_Ready(&eventlog_OpenBackupEventLogW_Type) < 0)
		goto out;
	if (PyType_Ready(&eventlog_ReadEventLogW_Type) < 0)
		goto out;
	if (PyType_Ready(&eventlog_ReportEventW_Type) < 0)
		goto out;
	if (PyType_Ready(&eventlog_GetLogInformation_Type) < 0)
		goto out;
	if (PyType_Ready(&eventlog_FlushEventLog_Type) < 0)
		goto out;
	if (PyType_Ready(&eventlog_ReportEventAndSourceW_Type) < 0)
		goto out;
	if (PyType_Ready(&eventlog_InterfaceType) < 0)
		goto out;
	if (PyType_Ready(&eventlog_SyntaxType) < 0)
		goto out;
	if (!PyInterface_AddNdrRpcMethods(&eventlog_InterfaceType, py_ndr_eventlog_methods))
		return NULL;

#ifdef PY_OPENUNKNOWN0_PATCH
	PY_OPENUNKNOWN0_PATCH(&eventlog_OpenUnknown0_Type);
#endif
#ifdef PY_RECORD_TDB_PATCH
	PY_RECORD_TDB_PATCH(&eventlog_Record_tdb_Type);
#endif
#ifdef PY_EVENTLOGHEADER_PATCH
	PY_EVENTLOGHEADER_PATCH(&EVENTLOGHEADER_Type);
#endif
#ifdef PY_EVENTLOGRECORD_PATCH
	PY_EVENTLOGRECORD_PATCH(&EVENTLOGRECORD_Type);
#endif
#ifdef PY_EVENTLOGEOF_PATCH
	PY_EVENTLOGEOF_PATCH(&EVENTLOGEOF_Type);
#endif
#ifdef PY_EVENTLOG_EVT_FILE_PATCH
	PY_EVENTLOG_EVT_FILE_PATCH(&EVENTLOG_EVT_FILE_Type);
#endif
#ifdef PY_EVENTLOG_FULL_INFORMATION_PATCH
	PY_EVENTLOG_FULL_INFORMATION_PATCH(&EVENTLOG_FULL_INFORMATION_Type);
#endif
#ifdef PY_CLEAREVENTLOGW_PATCH
	PY_CLEAREVENTLOGW_PATCH(&eventlog_ClearEventLogW_Type);
#endif
#ifdef PY_BACKUPEVENTLOGW_PATCH
	PY_BACKUPEVENTLOGW_PATCH(&eventlog_BackupEventLogW_Type);
#endif
#ifdef PY_CLOSEEVENTLOG_PATCH
	PY_CLOSEEVENTLOG_PATCH(&eventlog_CloseEventLog_Type);
#endif
#ifdef PY_DEREGISTEREVENTSOURCE_PATCH
	PY_DEREGISTEREVENTSOURCE_PATCH(&eventlog_DeregisterEventSource_Type);
#endif
#ifdef PY_GETNUMRECORDS_PATCH
	PY_GETNUMRECORDS_PATCH(&eventlog_GetNumRecords_Type);
#endif
#ifdef PY_GETOLDESTRECORD_PATCH
	PY_GETOLDESTRECORD_PATCH(&eventlog_GetOldestRecord_Type);
#endif
#ifdef PY_OPENEVENTLOGW_PATCH
	PY_OPENEVENTLOGW_PATCH(&eventlog_OpenEventLogW_Type);
#endif
#ifdef PY_REGISTEREVENTSOURCEW_PATCH
	PY_REGISTEREVENTSOURCEW_PATCH(&eventlog_RegisterEventSourceW_Type);
#endif
#ifdef PY_OPENBACKUPEVENTLOGW_PATCH
	PY_OPENBACKUPEVENTLOGW_PATCH(&eventlog_OpenBackupEventLogW_Type);
#endif
#ifdef PY_READEVENTLOGW_PATCH
	PY_READEVENTLOGW_PATCH(&eventlog_ReadEventLogW_Type);
#endif
#ifdef PY_REPORTEVENTW_PATCH
	PY_REPORTEVENTW_PATCH(&eventlog_ReportEventW_Type);
#endif
#ifdef PY_GETLOGINFORMATION_PATCH
	PY_GETLOGINFORMATION_PATCH(&eventlog_GetLogInformation_Type);
#endif
#ifdef PY_FLUSHEVENTLOG_PATCH
	PY_FLUSHEVENTLOG_PATCH(&eventlog_FlushEventLog_Type);
#endif
#ifdef PY_REPORTEVENTANDSOURCEW_PATCH
	PY_REPORTEVENTANDSOURCEW_PATCH(&eventlog_ReportEventAndSourceW_Type);
#endif
#ifdef PY_EVENTLOG_PATCH
	PY_EVENTLOG_PATCH(&eventlog_InterfaceType);
#endif
#ifdef PY_EVENTLOG_ABSTRACT_SYNTAX_PATCH
	PY_EVENTLOG_ABSTRACT_SYNTAX_PATCH(&eventlog_SyntaxType);
#endif
#ifdef PY_ABSTRACT_SYNTAX_PATCH
	PY_ABSTRACT_SYNTAX_PATCH(&eventlog_SyntaxType);
#endif

	m = PyModule_Create(&moduledef);
	if (m == NULL)
		goto out;

	PyModule_AddObject(m, "EVENTLOG_SEQUENTIAL_READ", PyLong_FromUnsignedLongLong((uint32_t)EVENTLOG_SEQUENTIAL_READ));
	PyModule_AddObject(m, "EVENTLOG_SEEK_READ", PyLong_FromUnsignedLongLong((uint32_t)EVENTLOG_SEEK_READ));
	PyModule_AddObject(m, "EVENTLOG_FORWARDS_READ", PyLong_FromUnsignedLongLong((uint32_t)EVENTLOG_FORWARDS_READ));
	PyModule_AddObject(m, "EVENTLOG_BACKWARDS_READ", PyLong_FromUnsignedLongLong((uint32_t)EVENTLOG_BACKWARDS_READ));
	PyModule_AddObject(m, "EVENTLOG_SUCCESS", PyLong_FromLong((uint16_t)EVENTLOG_SUCCESS));
	PyModule_AddObject(m, "EVENTLOG_ERROR_TYPE", PyLong_FromLong((uint16_t)EVENTLOG_ERROR_TYPE));
	PyModule_AddObject(m, "EVENTLOG_WARNING_TYPE", PyLong_FromLong((uint16_t)EVENTLOG_WARNING_TYPE));
	PyModule_AddObject(m, "EVENTLOG_INFORMATION_TYPE", PyLong_FromLong((uint16_t)EVENTLOG_INFORMATION_TYPE));
	PyModule_AddObject(m, "EVENTLOG_AUDIT_SUCCESS", PyLong_FromLong((uint16_t)EVENTLOG_AUDIT_SUCCESS));
	PyModule_AddObject(m, "EVENTLOG_AUDIT_FAILURE", PyLong_FromLong((uint16_t)EVENTLOG_AUDIT_FAILURE));
	PyModule_AddObject(m, "ELF_LOGFILE_HEADER_DIRTY", PyLong_FromUnsignedLongLong((uint32_t)ELF_LOGFILE_HEADER_DIRTY));
	PyModule_AddObject(m, "ELF_LOGFILE_HEADER_WRAP", PyLong_FromUnsignedLongLong((uint32_t)ELF_LOGFILE_HEADER_WRAP));
	PyModule_AddObject(m, "ELF_LOGFILE_LOGFULL_WRITTEN", PyLong_FromUnsignedLongLong((uint32_t)ELF_LOGFILE_LOGFULL_WRITTEN));
	PyModule_AddObject(m, "ELF_LOGFILE_ARCHIVE_SET", PyLong_FromUnsignedLongLong((uint32_t)ELF_LOGFILE_ARCHIVE_SET));
	Py_INCREF((PyObject *)(void *)&eventlog_OpenUnknown0_Type);
	PyModule_AddObject(m, "OpenUnknown0", (PyObject *)(void *)&eventlog_OpenUnknown0_Type);
	Py_INCREF((PyObject *)(void *)&eventlog_Record_tdb_Type);
	PyModule_AddObject(m, "Record_tdb", (PyObject *)(void *)&eventlog_Record_tdb_Type);
	Py_INCREF((PyObject *)(void *)&EVENTLOGHEADER_Type);
	PyModule_AddObject(m, "EVENTLOGHEADER", (PyObject *)(void *)&EVENTLOGHEADER_Type);
	Py_INCREF((PyObject *)(void *)&EVENTLOGRECORD_Type);
	PyModule_AddObject(m, "EVENTLOGRECORD", (PyObject *)(void *)&EVENTLOGRECORD_Type);
	Py_INCREF((PyObject *)(void *)&EVENTLOGEOF_Type);
	PyModule_AddObject(m, "EVENTLOGEOF", (PyObject *)(void *)&EVENTLOGEOF_Type);
	Py_INCREF((PyObject *)(void *)&EVENTLOG_EVT_FILE_Type);
	PyModule_AddObject(m, "EVENTLOG_EVT_FILE", (PyObject *)(void *)&EVENTLOG_EVT_FILE_Type);
	Py_INCREF((PyObject *)(void *)&EVENTLOG_FULL_INFORMATION_Type);
	PyModule_AddObject(m, "EVENTLOG_FULL_INFORMATION", (PyObject *)(void *)&EVENTLOG_FULL_INFORMATION_Type);
	Py_INCREF((PyObject *)(void *)&eventlog_ClearEventLogW_Type);
	PyModule_AddObject(m, "ClearEventLogW", (PyObject *)(void *)&eventlog_ClearEventLogW_Type);
	Py_INCREF((PyObject *)(void *)&eventlog_BackupEventLogW_Type);
	PyModule_AddObject(m, "BackupEventLogW", (PyObject *)(void *)&eventlog_BackupEventLogW_Type);
	Py_INCREF((PyObject *)(void *)&eventlog_CloseEventLog_Type);
	PyModule_AddObject(m, "CloseEventLog", (PyObject *)(void *)&eventlog_CloseEventLog_Type);
	Py_INCREF((PyObject *)(void *)&eventlog_DeregisterEventSource_Type);
	PyModule_AddObject(m, "DeregisterEventSource", (PyObject *)(void *)&eventlog_DeregisterEventSource_Type);
	Py_INCREF((PyObject *)(void *)&eventlog_GetNumRecords_Type);
	PyModule_AddObject(m, "GetNumRecords", (PyObject *)(void *)&eventlog_GetNumRecords_Type);
	Py_INCREF((PyObject *)(void *)&eventlog_GetOldestRecord_Type);
	PyModule_AddObject(m, "GetOldestRecord", (PyObject *)(void *)&eventlog_GetOldestRecord_Type);
	Py_INCREF((PyObject *)(void *)&eventlog_OpenEventLogW_Type);
	PyModule_AddObject(m, "OpenEventLogW", (PyObject *)(void *)&eventlog_OpenEventLogW_Type);
	Py_INCREF((PyObject *)(void *)&eventlog_RegisterEventSourceW_Type);
	PyModule_AddObject(m, "RegisterEventSourceW", (PyObject *)(void *)&eventlog_RegisterEventSourceW_Type);
	Py_INCREF((PyObject *)(void *)&eventlog_OpenBackupEventLogW_Type);
	PyModule_AddObject(m, "OpenBackupEventLogW", (PyObject *)(void *)&eventlog_OpenBackupEventLogW_Type);
	Py_INCREF((PyObject *)(void *)&eventlog_ReadEventLogW_Type);
	PyModule_AddObject(m, "ReadEventLogW", (PyObject *)(void *)&eventlog_ReadEventLogW_Type);
	Py_INCREF((PyObject *)(void *)&eventlog_ReportEventW_Type);
	PyModule_AddObject(m, "ReportEventW", (PyObject *)(void *)&eventlog_ReportEventW_Type);
	Py_INCREF((PyObject *)(void *)&eventlog_GetLogInformation_Type);
	PyModule_AddObject(m, "GetLogInformation", (PyObject *)(void *)&eventlog_GetLogInformation_Type);
	Py_INCREF((PyObject *)(void *)&eventlog_FlushEventLog_Type);
	PyModule_AddObject(m, "FlushEventLog", (PyObject *)(void *)&eventlog_FlushEventLog_Type);
	Py_INCREF((PyObject *)(void *)&eventlog_ReportEventAndSourceW_Type);
	PyModule_AddObject(m, "ReportEventAndSourceW", (PyObject *)(void *)&eventlog_ReportEventAndSourceW_Type);
	Py_INCREF((PyObject *)(void *)&eventlog_InterfaceType);
	PyModule_AddObject(m, "eventlog", (PyObject *)(void *)&eventlog_InterfaceType);
	Py_INCREF((PyObject *)(void *)&eventlog_SyntaxType);
	PyModule_AddObject(m, "eventlog_abstract_syntax", (PyObject *)(void *)&eventlog_SyntaxType);
	Py_INCREF((PyObject *)(void *)&eventlog_SyntaxType);
	PyModule_AddObject(m, "abstract_syntax", (PyObject *)(void *)&eventlog_SyntaxType);
#ifdef PY_MOD_EVENTLOG_PATCH
	PY_MOD_EVENTLOG_PATCH(m);
#endif
	out:
	Py_XDECREF(dep_samba_dcerpc_lsa);
	Py_XDECREF(dep_samba_dcerpc_security);
	Py_XDECREF(dep_talloc);
	Py_XDECREF(dep_samba_dcerpc_misc);
	Py_XDECREF(dep_samba_dcerpc_base);
	return m;

}