Cython: message.py

Yellow lines hint at Python interaction.
Click on a line that starts with a "+" to see the C code that Cython generated for it.

+001: from typing import Any, List, Optional, Union

  __pyx_t_1 = PyList_New(4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_INCREF(__pyx_n_s_Any);
  __Pyx_GIVEREF(__pyx_n_s_Any);
  PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_Any);
  __Pyx_INCREF(__pyx_n_s_List);
  __Pyx_GIVEREF(__pyx_n_s_List);
  PyList_SET_ITEM(__pyx_t_1, 1, __pyx_n_s_List);
  __Pyx_INCREF(__pyx_n_s_Optional);
  __Pyx_GIVEREF(__pyx_n_s_Optional);
  PyList_SET_ITEM(__pyx_t_1, 2, __pyx_n_s_Optional);
  __Pyx_INCREF(__pyx_n_s_Union);
  __Pyx_GIVEREF(__pyx_n_s_Union);
  PyList_SET_ITEM(__pyx_t_1, 3, __pyx_n_s_Union);
  __pyx_t_2 = __Pyx_Import(__pyx_n_s_typing, __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_Any); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_Any, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_List); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_List, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_Optional); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_Optional, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_Union); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_Union, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 002:

+003: from ._private.constants import LITTLE_ENDIAN, PROTOCOL_VERSION, HeaderField

  __pyx_t_2 = PyList_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_INCREF(__pyx_n_s_LITTLE_ENDIAN);
  __Pyx_GIVEREF(__pyx_n_s_LITTLE_ENDIAN);
  PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_LITTLE_ENDIAN);
  __Pyx_INCREF(__pyx_n_s_PROTOCOL_VERSION);
  __Pyx_GIVEREF(__pyx_n_s_PROTOCOL_VERSION);
  PyList_SET_ITEM(__pyx_t_2, 1, __pyx_n_s_PROTOCOL_VERSION);
  __Pyx_INCREF(__pyx_n_s_HeaderField);
  __Pyx_GIVEREF(__pyx_n_s_HeaderField);
  PyList_SET_ITEM(__pyx_t_2, 2, __pyx_n_s_HeaderField);
  __pyx_t_1 = __Pyx_Import(__pyx_n_s_private_constants, __pyx_t_2, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_LITTLE_ENDIAN); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_INCREF(__pyx_t_2);
  __Pyx_XGOTREF(__pyx_v_9dbus_fast_7message_LITTLE_ENDIAN);
  __Pyx_DECREF_SET(__pyx_v_9dbus_fast_7message_LITTLE_ENDIAN, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_PROTOCOL_VERSION); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_INCREF(__pyx_t_2);
  __Pyx_XGOTREF(__pyx_v_9dbus_fast_7message_PROTOCOL_VERSION);
  __Pyx_DECREF_SET(__pyx_v_9dbus_fast_7message_PROTOCOL_VERSION, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_HeaderField); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_HeaderField, __pyx_t_2) < 0) __PYX_ERR(0, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+004: from ._private.marshaller import Marshaller

  __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_INCREF(__pyx_n_s_Marshaller);
  __Pyx_GIVEREF(__pyx_n_s_Marshaller);
  PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_Marshaller);
  __pyx_t_2 = __Pyx_Import(__pyx_n_s_private_marshaller, __pyx_t_1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_Marshaller); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_INCREF(__pyx_t_1);
  __Pyx_XGOTREF(__pyx_v_9dbus_fast_7message_Marshaller);
  __Pyx_DECREF_SET(__pyx_v_9dbus_fast_7message_Marshaller, __pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+005: from .constants import ErrorType, MessageFlag, MessageType

  __pyx_t_2 = PyList_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_INCREF(__pyx_n_s_ErrorType);
  __Pyx_GIVEREF(__pyx_n_s_ErrorType);
  PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_ErrorType);
  __Pyx_INCREF(__pyx_n_s_MessageFlag);
  __Pyx_GIVEREF(__pyx_n_s_MessageFlag);
  PyList_SET_ITEM(__pyx_t_2, 1, __pyx_n_s_MessageFlag);
  __Pyx_INCREF(__pyx_n_s_MessageType);
  __Pyx_GIVEREF(__pyx_n_s_MessageType);
  PyList_SET_ITEM(__pyx_t_2, 2, __pyx_n_s_MessageType);
  __pyx_t_1 = __Pyx_Import(__pyx_n_s_constants, __pyx_t_2, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_ErrorType); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_INCREF(__pyx_t_2);
  __Pyx_XGOTREF(__pyx_v_9dbus_fast_7message_ErrorType);
  __Pyx_DECREF_SET(__pyx_v_9dbus_fast_7message_ErrorType, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_MessageFlag); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_MessageFlag, __pyx_t_2) < 0) __PYX_ERR(0, 5, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_MessageType); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_INCREF(__pyx_t_2);
  __Pyx_XGOTREF(__pyx_v_9dbus_fast_7message_MessageType);
  __Pyx_DECREF_SET(__pyx_v_9dbus_fast_7message_MessageType, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+006: from .errors import InvalidMessageError

  __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_INCREF(__pyx_n_s_InvalidMessageError);
  __Pyx_GIVEREF(__pyx_n_s_InvalidMessageError);
  PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_InvalidMessageError);
  __pyx_t_2 = __Pyx_Import(__pyx_n_s_errors, __pyx_t_1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 6, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_InvalidMessageError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_InvalidMessageError, __pyx_t_1) < 0) __PYX_ERR(0, 6, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+007: from .signature import SignatureTree, Variant, get_signature_tree

  __pyx_t_2 = PyList_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 7, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_INCREF(__pyx_n_s_SignatureTree);
  __Pyx_GIVEREF(__pyx_n_s_SignatureTree);
  PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_SignatureTree);
  __Pyx_INCREF(__pyx_n_s_Variant);
  __Pyx_GIVEREF(__pyx_n_s_Variant);
  PyList_SET_ITEM(__pyx_t_2, 1, __pyx_n_s_Variant);
  __Pyx_INCREF(__pyx_n_s_get_signature_tree);
  __Pyx_GIVEREF(__pyx_n_s_get_signature_tree);
  PyList_SET_ITEM(__pyx_t_2, 2, __pyx_n_s_get_signature_tree);
  __pyx_t_1 = __Pyx_Import(__pyx_n_s_signature, __pyx_t_2, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 7, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_SignatureTree); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 7, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_INCREF(__pyx_t_2);
  __Pyx_XGOTREF(__pyx_v_9dbus_fast_7message_SignatureTree);
  __Pyx_DECREF_SET(__pyx_v_9dbus_fast_7message_SignatureTree, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_Variant); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 7, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_INCREF(__pyx_t_2);
  __Pyx_XGOTREF(__pyx_v_9dbus_fast_7message_Variant);
  __Pyx_DECREF_SET(__pyx_v_9dbus_fast_7message_Variant, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_get_signature_tree); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 7, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_INCREF(__pyx_t_2);
  __Pyx_XGOTREF(__pyx_v_9dbus_fast_7message_get_signature_tree);
  __Pyx_DECREF_SET(__pyx_v_9dbus_fast_7message_get_signature_tree, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+008: from .validators import (

  __pyx_t_2 = __Pyx_Import(__pyx_n_s_validators, __pyx_t_1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 8, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_assert_bus_name_valid); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_assert_bus_name_valid, __pyx_t_1) < 0) __PYX_ERR(0, 9, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_assert_interface_name_valid); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_assert_interface_name_valid, __pyx_t_1) < 0) __PYX_ERR(0, 10, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_assert_member_name_valid); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_assert_member_name_valid, __pyx_t_1) < 0) __PYX_ERR(0, 11, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_assert_object_path_valid); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_assert_object_path_valid, __pyx_t_1) < 0) __PYX_ERR(0, 12, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+009:     assert_bus_name_valid,

  __pyx_t_1 = PyList_New(4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 9, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_INCREF(__pyx_n_s_assert_bus_name_valid);
  __Pyx_GIVEREF(__pyx_n_s_assert_bus_name_valid);
  PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_assert_bus_name_valid);
  __Pyx_INCREF(__pyx_n_s_assert_interface_name_valid);
  __Pyx_GIVEREF(__pyx_n_s_assert_interface_name_valid);
  PyList_SET_ITEM(__pyx_t_1, 1, __pyx_n_s_assert_interface_name_valid);
  __Pyx_INCREF(__pyx_n_s_assert_member_name_valid);
  __Pyx_GIVEREF(__pyx_n_s_assert_member_name_valid);
  PyList_SET_ITEM(__pyx_t_1, 2, __pyx_n_s_assert_member_name_valid);
  __Pyx_INCREF(__pyx_n_s_assert_object_path_valid);
  __Pyx_GIVEREF(__pyx_n_s_assert_object_path_valid);
  PyList_SET_ITEM(__pyx_t_1, 3, __pyx_n_s_assert_object_path_valid);

 010:     assert_interface_name_valid,

 011:     assert_member_name_valid,

 012:     assert_object_path_valid,

 013: )

 014:

 015: REQUIRED_FIELDS = {

+016:     MessageType.METHOD_CALL: ("path", "member"),

  __pyx_t_2 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 16, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_9dbus_fast_7message_MessageType, __pyx_n_s_METHOD_CALL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 16, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_t_2, __pyx_t_1, __pyx_tuple__9) < 0) __PYX_ERR(0, 16, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* … */
  __pyx_tuple__9 = PyTuple_Pack(2, __pyx_n_u_path, __pyx_n_u_member); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(0, 16, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__9);
  __Pyx_GIVEREF(__pyx_tuple__9);

+017:     MessageType.SIGNAL: ("path", "member", "interface"),

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_9dbus_fast_7message_MessageType, __pyx_n_s_SIGNAL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 17, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_t_2, __pyx_t_1, __pyx_tuple__10) < 0) __PYX_ERR(0, 16, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* … */
  __pyx_tuple__10 = PyTuple_Pack(3, __pyx_n_u_path, __pyx_n_u_member, __pyx_n_u_interface); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 17, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__10);
  __Pyx_GIVEREF(__pyx_tuple__10);

+018:     MessageType.ERROR: ("error_name", "reply_serial"),

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_9dbus_fast_7message_MessageType, __pyx_n_s_ERROR); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 18, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_t_2, __pyx_t_1, __pyx_tuple__11) < 0) __PYX_ERR(0, 16, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* … */
  __pyx_tuple__11 = PyTuple_Pack(2, __pyx_n_u_error_name, __pyx_n_u_reply_serial); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(0, 18, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__11);
  __Pyx_GIVEREF(__pyx_tuple__11);

+019:     MessageType.METHOD_RETURN: ("reply_serial",),

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_9dbus_fast_7message_MessageType, __pyx_n_s_METHOD_RETURN); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 19, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_t_2, __pyx_t_1, __pyx_tuple__12) < 0) __PYX_ERR(0, 16, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_REQUIRED_FIELDS, __pyx_t_2) < 0) __PYX_ERR(0, 15, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* … */
  __pyx_tuple__12 = PyTuple_Pack(1, __pyx_n_u_reply_serial); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(0, 19, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__12);
  __Pyx_GIVEREF(__pyx_tuple__12);

 020: }

 021:

+022: HEADER_PATH = HeaderField.PATH.value

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_HeaderField); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 22, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_PATH); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 22, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 22, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_XGOTREF(__pyx_v_9dbus_fast_7message_HEADER_PATH);
  __Pyx_DECREF_SET(__pyx_v_9dbus_fast_7message_HEADER_PATH, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_2);
  __pyx_t_2 = 0;

+023: HEADER_INTERFACE = HeaderField.INTERFACE.value

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_HeaderField); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 23, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_INTERFACE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 23, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 23, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_XGOTREF(__pyx_v_9dbus_fast_7message_HEADER_INTERFACE);
  __Pyx_DECREF_SET(__pyx_v_9dbus_fast_7message_HEADER_INTERFACE, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_2);
  __pyx_t_2 = 0;

+024: HEADER_MEMBER = HeaderField.MEMBER.value

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_HeaderField); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 24, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_MEMBER); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 24, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 24, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_XGOTREF(__pyx_v_9dbus_fast_7message_HEADER_MEMBER);
  __Pyx_DECREF_SET(__pyx_v_9dbus_fast_7message_HEADER_MEMBER, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_2);
  __pyx_t_2 = 0;

+025: HEADER_ERROR_NAME = HeaderField.ERROR_NAME.value

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_HeaderField); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 25, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_ERROR_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 25, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 25, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_XGOTREF(__pyx_v_9dbus_fast_7message_HEADER_ERROR_NAME);
  __Pyx_DECREF_SET(__pyx_v_9dbus_fast_7message_HEADER_ERROR_NAME, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_2);
  __pyx_t_2 = 0;

+026: HEADER_REPLY_SERIAL = HeaderField.REPLY_SERIAL.value

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_HeaderField); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 26, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_REPLY_SERIAL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 26, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 26, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_XGOTREF(__pyx_v_9dbus_fast_7message_HEADER_REPLY_SERIAL);
  __Pyx_DECREF_SET(__pyx_v_9dbus_fast_7message_HEADER_REPLY_SERIAL, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_2);
  __pyx_t_2 = 0;

+027: HEADER_DESTINATION = HeaderField.DESTINATION.value

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_HeaderField); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 27, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_DESTINATION); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 27, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 27, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_XGOTREF(__pyx_v_9dbus_fast_7message_HEADER_DESTINATION);
  __Pyx_DECREF_SET(__pyx_v_9dbus_fast_7message_HEADER_DESTINATION, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_2);
  __pyx_t_2 = 0;

+028: HEADER_SIGNATURE = HeaderField.SIGNATURE.value

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_HeaderField); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 28, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_SIGNATURE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 28, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 28, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_XGOTREF(__pyx_v_9dbus_fast_7message_HEADER_SIGNATURE);
  __Pyx_DECREF_SET(__pyx_v_9dbus_fast_7message_HEADER_SIGNATURE, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_2);
  __pyx_t_2 = 0;

+029: HEADER_UNIX_FDS = HeaderField.UNIX_FDS.value

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_HeaderField); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 29, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_UNIX_FDS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 29, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 29, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_XGOTREF(__pyx_v_9dbus_fast_7message_HEADER_UNIX_FDS);
  __Pyx_DECREF_SET(__pyx_v_9dbus_fast_7message_HEADER_UNIX_FDS, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_2);
  __pyx_t_2 = 0;

 030:

 031:

+032: class Message:

struct __pyx_vtabstruct_9dbus_fast_7message_Message {
  PyObject *(*_marshall)(struct __pyx_obj_9dbus_fast_7message_Message *, int, int __pyx_skip_dispatch);
};
static struct __pyx_vtabstruct_9dbus_fast_7message_Message *__pyx_vtabptr_9dbus_fast_7message_Message;

 033:     """A class for sending and receiving messages through the

 034:     :class:`MessageBus <dbus_fast.message_bus.BaseMessageBus>` with the

 035:     low-level api.

 036:

 037:     A ``Message`` can be constructed by the user to send over the message bus.

 038:     When messages are received, such as from method calls or signal emissions,

 039:     they will use this class as well.

 040:

 041:     :ivar destination: The address of the client for which this message is intended.

 042:     :vartype destination: str

 043:     :ivar path: The intended object path exported on the destination bus.

 044:     :vartype path: str

 045:     :ivar interface: The intended interface on the object path.

 046:     :vartype interface: str

 047:     :ivar member: The intended member on the interface.

 048:     :vartype member: str

 049:     :ivar message_type: The type of this message. A method call, signal, method return, or error.

 050:     :vartype message_type: :class:`MessageType`

 051:     :ivar flags: Flags that affect the behavior of this message.

 052:     :vartype flags: :class:`MessageFlag`

 053:     :ivar error_name: If this message is an error, the name of this error. Must be a valid interface name.

 054:     :vartype error_name: str

 055:     :ivar reply_serial: If this is a return type, the serial this message is in reply to.

 056:     :vartype reply_serial: int

 057:     :ivar sender: The address of the sender of this message. Will be a unique name.

 058:     :vartype sender: str

 059:     :ivar unix_fds: A list of unix fds that were sent in the header of this message.

 060:     :vartype unix_fds: list(int)

 061:     :ivar signature: The signature of the body of this message.

 062:     :vartype signature: str

 063:     :ivar signature_tree: The signature parsed as a signature tree.

 064:     :vartype signature_tree: :class:`SignatureTree`

 065:     :ivar body: The body of this message. Must match the signature.

 066:     :vartype body: list(Any)

 067:     :ivar serial: The serial of the message. Will be automatically set during message sending if not present. Use the ``new_serial()`` method of the bus to generate a serial.

 068:     :vartype serial: int

 069:

 070:     :raises:

 071:         - :class:`InvalidMessageError` - If the message is malformed or missing fields for the message type.

 072:         - :class:`InvalidSignatureError` - If the given signature is not valid.

 073:         - :class:`InvalidObjectPathError` - If ``path`` is not a valid object path.

 074:         - :class:`InvalidBusNameError` - If ``destination`` is not a valid bus name.

 075:         - :class:`InvalidMemberNameError` - If ``member`` is not a valid member name.

 076:         - :class:`InvalidInterfaceNameError` - If ``error_name`` or ``interface`` is not a valid interface name.

 077:     """

 078:

 079:     __slots__ = (

+080:         "destination",

  if (PyDict_SetItem((PyObject *)__pyx_ptype_9dbus_fast_7message_Message->tp_dict, __pyx_n_s_slots, __pyx_tuple__13) < 0) __PYX_ERR(0, 79, __pyx_L1_error)
  PyType_Modified(__pyx_ptype_9dbus_fast_7message_Message);
/* … */
  __pyx_tuple__13 = PyTuple_Pack(14, __pyx_n_u_destination, __pyx_n_u_path, __pyx_n_u_interface, __pyx_n_u_member, __pyx_n_u_message_type, __pyx_n_u_flags, __pyx_n_u_error_name, __pyx_n_u_reply_serial, __pyx_n_u_sender, __pyx_n_u_unix_fds, __pyx_n_u_signature, __pyx_n_u_signature_tree, __pyx_n_u_body, __pyx_n_u_serial); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(0, 80, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__13);
  __Pyx_GIVEREF(__pyx_tuple__13);

 081:         "path",

 082:         "interface",

 083:         "member",

 084:         "message_type",

 085:         "flags",

 086:         "error_name",

 087:         "reply_serial",

 088:         "sender",

 089:         "unix_fds",

 090:         "signature",

 091:         "signature_tree",

 092:         "body",

 093:         "serial",

 094:     )

 095:

+096:     def __init__(

/* Python wrapper */
static int __pyx_pw_9dbus_fast_7message_7Message_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_9dbus_fast_7message_7Message_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_destination = 0;
  PyObject *__pyx_v_path = 0;
  PyObject *__pyx_v_interface = 0;
  PyObject *__pyx_v_member = 0;
  PyObject *__pyx_v_message_type = 0;
  PyObject *__pyx_v_flags = 0;
  PyObject *__pyx_v_error_name = 0;
  PyObject *__pyx_v_reply_serial = 0;
  PyObject *__pyx_v_sender = 0;
  PyObject *__pyx_v_unix_fds = 0;
  PyObject *__pyx_v_signature = 0;
  PyObject *__pyx_v_body = 0;
  PyObject *__pyx_v_serial = 0;
  PyObject *__pyx_v_validate = 0;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_destination,&__pyx_n_s_path,&__pyx_n_s_interface,&__pyx_n_s_member,&__pyx_n_s_message_type,&__pyx_n_s_flags,&__pyx_n_s_error_name,&__pyx_n_s_reply_serial,&__pyx_n_s_sender,&__pyx_n_s_unix_fds,&__pyx_n_s_signature,&__pyx_n_s_body,&__pyx_n_s_serial,&__pyx_n_s_validate,0};
    PyObject* values[14] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0};
/* … */
  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_9dbus_fast_7message_7Message___init__(struct __pyx_obj_9dbus_fast_7message_Message *__pyx_v_self, PyObject *__pyx_v_destination, PyObject *__pyx_v_path, PyObject *__pyx_v_interface, PyObject *__pyx_v_member, PyObject *__pyx_v_message_type, PyObject *__pyx_v_flags, PyObject *__pyx_v_error_name, PyObject *__pyx_v_reply_serial, PyObject *__pyx_v_sender, PyObject *__pyx_v_unix_fds, PyObject *__pyx_v_signature, PyObject *__pyx_v_body, PyObject *__pyx_v_serial, PyObject *__pyx_v_validate) {
  PyObject *__pyx_v_required_fields = NULL;
  PyObject *__pyx_v_field = NULL;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__init__", 0);
/* … */
  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_AddTraceback("dbus_fast.message.Message.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_required_fields);
  __Pyx_XDECREF(__pyx_v_field);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 097:         self,

+098:         destination: Optional[str] = None,

    values[0] = ((PyObject *)Py_None);

+099:         path: Optional[str] = None,

    values[1] = ((PyObject *)Py_None);

+100:         interface: Optional[str] = None,

    values[2] = ((PyObject *)Py_None);

+101:         member: Optional[str] = None,

    values[3] = ((PyObject *)Py_None);
    values[4] = __pyx_k_;
    values[5] = __pyx_k__2;

+102:         message_type: MessageType = MessageType.METHOD_CALL,

  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_9dbus_fast_7message_MessageType, __pyx_n_s_METHOD_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 102, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_k_ = __pyx_t_2;
  __Pyx_GIVEREF(__pyx_t_2);
  __pyx_t_2 = 0;

+103:         flags: Union[MessageFlag, int] = MessageFlag.NONE,

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_MessageFlag); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 103, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_NONE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 103, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_k__2 = __pyx_t_1;
  __Pyx_GIVEREF(__pyx_t_1);
  __pyx_t_1 = 0;

+104:         error_name: Optional[Union[str, ErrorType]] = None,

    values[6] = ((PyObject *)Py_None);
    values[7] = ((PyObject *)__pyx_int_0);

 105:         reply_serial: int = 0,

+106:         sender: Optional[str] = None,

    values[8] = ((PyObject *)Py_None);
    values[9] = __pyx_k__3;

+107:         unix_fds: List[int] = [],

  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 107, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_k__3 = __pyx_t_1;
  __Pyx_GIVEREF(__pyx_t_1);
  __pyx_t_1 = 0;

+108:         signature: Optional[Union[SignatureTree, str]] = None,

    values[10] = ((PyObject *)Py_None);
    values[11] = __pyx_k__4;
    values[12] = ((PyObject *)__pyx_int_0);

+109:         body: List[Any] = [],

  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 109, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_k__4 = __pyx_t_1;
  __Pyx_GIVEREF(__pyx_t_1);
  __pyx_t_1 = 0;

 110:         serial: int = 0,

+111:         validate: bool = True,

    values[13] = ((PyObject *)Py_True);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case 14: values[13] = PyTuple_GET_ITEM(__pyx_args, 13);
        CYTHON_FALLTHROUGH;
        case 13: values[12] = PyTuple_GET_ITEM(__pyx_args, 12);
        CYTHON_FALLTHROUGH;
        case 12: values[11] = PyTuple_GET_ITEM(__pyx_args, 11);
        CYTHON_FALLTHROUGH;
        case 11: values[10] = PyTuple_GET_ITEM(__pyx_args, 10);
        CYTHON_FALLTHROUGH;
        case 10: values[9] = PyTuple_GET_ITEM(__pyx_args, 9);
        CYTHON_FALLTHROUGH;
        case  9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8);
        CYTHON_FALLTHROUGH;
        case  8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
        CYTHON_FALLTHROUGH;
        case  7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
        CYTHON_FALLTHROUGH;
        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
        CYTHON_FALLTHROUGH;
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        CYTHON_FALLTHROUGH;
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_destination);
          if (value) { values[0] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_path);
          if (value) { values[1] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_interface);
          if (value) { values[2] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  3:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_member);
          if (value) { values[3] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  4:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_message_type);
          if (value) { values[4] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  5:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_flags);
          if (value) { values[5] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  6:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_error_name);
          if (value) { values[6] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  7:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_reply_serial);
          if (value) { values[7] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  8:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_sender);
          if (value) { values[8] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  9:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_unix_fds);
          if (value) { values[9] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case 10:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_signature);
          if (value) { values[10] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case 11:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_body);
          if (value) { values[11] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case 12:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_serial);
          if (value) { values[12] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case 13:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_validate);
          if (value) { values[13] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 96, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case 14: values[13] = PyTuple_GET_ITEM(__pyx_args, 13);
        CYTHON_FALLTHROUGH;
        case 13: values[12] = PyTuple_GET_ITEM(__pyx_args, 12);
        CYTHON_FALLTHROUGH;
        case 12: values[11] = PyTuple_GET_ITEM(__pyx_args, 11);
        CYTHON_FALLTHROUGH;
        case 11: values[10] = PyTuple_GET_ITEM(__pyx_args, 10);
        CYTHON_FALLTHROUGH;
        case 10: values[9] = PyTuple_GET_ITEM(__pyx_args, 9);
        CYTHON_FALLTHROUGH;
        case  9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8);
        CYTHON_FALLTHROUGH;
        case  8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
        CYTHON_FALLTHROUGH;
        case  7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
        CYTHON_FALLTHROUGH;
        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
        CYTHON_FALLTHROUGH;
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        CYTHON_FALLTHROUGH;
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_destination = values[0];
    __pyx_v_path = values[1];
    __pyx_v_interface = values[2];
    __pyx_v_member = values[3];
    __pyx_v_message_type = values[4];
    __pyx_v_flags = values[5];
    __pyx_v_error_name = values[6];
    __pyx_v_reply_serial = values[7];
    __pyx_v_sender = values[8];
    __pyx_v_unix_fds = values[9];
    __pyx_v_signature = values[10];
    __pyx_v_body = values[11];
    __pyx_v_serial = values[12];
    __pyx_v_validate = values[13];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__init__", 0, 0, 14, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 96, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("dbus_fast.message.Message.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return -1;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9dbus_fast_7message_7Message___init__(((struct __pyx_obj_9dbus_fast_7message_Message *)__pyx_v_self), __pyx_v_destination, __pyx_v_path, __pyx_v_interface, __pyx_v_member, __pyx_v_message_type, __pyx_v_flags, __pyx_v_error_name, __pyx_v_reply_serial, __pyx_v_sender, __pyx_v_unix_fds, __pyx_v_signature, __pyx_v_body, __pyx_v_serial, __pyx_v_validate);

 112:     ) -> None:

+113:         self.destination = destination

  __Pyx_INCREF(__pyx_v_destination);
  __Pyx_GIVEREF(__pyx_v_destination);
  __Pyx_GOTREF(__pyx_v_self->destination);
  __Pyx_DECREF(__pyx_v_self->destination);
  __pyx_v_self->destination = __pyx_v_destination;

+114:         self.path = path

  __Pyx_INCREF(__pyx_v_path);
  __Pyx_GIVEREF(__pyx_v_path);
  __Pyx_GOTREF(__pyx_v_self->path);
  __Pyx_DECREF(__pyx_v_self->path);
  __pyx_v_self->path = __pyx_v_path;

+115:         self.interface = interface

  __Pyx_INCREF(__pyx_v_interface);
  __Pyx_GIVEREF(__pyx_v_interface);
  __Pyx_GOTREF(__pyx_v_self->interface);
  __Pyx_DECREF(__pyx_v_self->interface);
  __pyx_v_self->interface = __pyx_v_interface;

+116:         self.member = member

  __Pyx_INCREF(__pyx_v_member);
  __Pyx_GIVEREF(__pyx_v_member);
  __Pyx_GOTREF(__pyx_v_self->member);
  __Pyx_DECREF(__pyx_v_self->member);
  __pyx_v_self->member = __pyx_v_member;

+117:         self.message_type = message_type

  __Pyx_INCREF(__pyx_v_message_type);
  __Pyx_GIVEREF(__pyx_v_message_type);
  __Pyx_GOTREF(__pyx_v_self->message_type);
  __Pyx_DECREF(__pyx_v_self->message_type);
  __pyx_v_self->message_type = __pyx_v_message_type;

+118:         self.flags = flags if type(flags) is MessageFlag else MessageFlag(flags)

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_MessageFlag); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 118, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = (((PyObject *)Py_TYPE(__pyx_v_flags)) == __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if ((__pyx_t_3 != 0)) {
    __Pyx_INCREF(__pyx_v_flags);
    __pyx_t_1 = __pyx_v_flags;
  } else {
    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_MessageFlag); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 118, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_5 = NULL;
    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
      __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
      if (likely(__pyx_t_5)) {
        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
        __Pyx_INCREF(__pyx_t_5);
        __Pyx_INCREF(function);
        __Pyx_DECREF_SET(__pyx_t_4, function);
      }
    }
    __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_v_flags) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_flags);
    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 118, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_1 = __pyx_t_2;
    __pyx_t_2 = 0;
  }
  __Pyx_GIVEREF(__pyx_t_1);
  __Pyx_GOTREF(__pyx_v_self->flags);
  __Pyx_DECREF(__pyx_v_self->flags);
  __pyx_v_self->flags = __pyx_t_1;
  __pyx_t_1 = 0;

+119:         self.error_name = (

  __Pyx_GIVEREF(__pyx_t_1);
  __Pyx_GOTREF(__pyx_v_self->error_name);
  __Pyx_DECREF(__pyx_v_self->error_name);
  __pyx_v_self->error_name = __pyx_t_1;
  __pyx_t_1 = 0;

+120:             str(error_name.value) if type(error_name) is ErrorType else error_name

  __pyx_t_3 = (((PyObject *)Py_TYPE(__pyx_v_error_name)) == __pyx_v_9dbus_fast_7message_ErrorType);
  if ((__pyx_t_3 != 0)) {
    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_error_name, __pyx_n_s_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 120, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_4 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyUnicode_Type)), __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 120, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_1 = __pyx_t_4;
    __pyx_t_4 = 0;
  } else {
    __Pyx_INCREF(__pyx_v_error_name);
    __pyx_t_1 = __pyx_v_error_name;
  }

 121:         )

+122:         self.reply_serial = reply_serial or 0

  __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_reply_serial); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 122, __pyx_L1_error)
  if (!__pyx_t_3) {
  } else {
    __pyx_t_7 = __Pyx_PyInt_As_unsigned_int(__pyx_v_reply_serial); if (unlikely((__pyx_t_7 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 122, __pyx_L1_error)
    __pyx_t_6 = __pyx_t_7;
    goto __pyx_L3_bool_binop_done;
  }
  __pyx_t_6 = 0;
  __pyx_L3_bool_binop_done:;
  __pyx_v_self->reply_serial = __pyx_t_6;

+123:         self.sender = sender

  __Pyx_INCREF(__pyx_v_sender);
  __Pyx_GIVEREF(__pyx_v_sender);
  __Pyx_GOTREF(__pyx_v_self->sender);
  __Pyx_DECREF(__pyx_v_self->sender);
  __pyx_v_self->sender = __pyx_v_sender;

+124:         self.unix_fds = unix_fds

  __Pyx_INCREF(__pyx_v_unix_fds);
  __Pyx_GIVEREF(__pyx_v_unix_fds);
  __Pyx_GOTREF(__pyx_v_self->unix_fds);
  __Pyx_DECREF(__pyx_v_self->unix_fds);
  __pyx_v_self->unix_fds = __pyx_v_unix_fds;

+125:         if type(signature) is SignatureTree:

  __pyx_t_3 = (((PyObject *)Py_TYPE(__pyx_v_signature)) == __pyx_v_9dbus_fast_7message_SignatureTree);
  __pyx_t_8 = (__pyx_t_3 != 0);
  if (__pyx_t_8) {
/* … */
    goto __pyx_L5;
  }

+126:             self.signature = signature.signature

    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_signature, __pyx_n_s_signature); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 126, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_GIVEREF(__pyx_t_1);
    __Pyx_GOTREF(__pyx_v_self->signature);
    __Pyx_DECREF(__pyx_v_self->signature);
    __pyx_v_self->signature = __pyx_t_1;
    __pyx_t_1 = 0;

+127:             self.signature_tree = signature

    __Pyx_INCREF(__pyx_v_signature);
    __Pyx_GIVEREF(__pyx_v_signature);
    __Pyx_GOTREF(__pyx_v_self->signature_tree);
    __Pyx_DECREF(__pyx_v_self->signature_tree);
    __pyx_v_self->signature_tree = __pyx_v_signature;

 128:         else:

+129:             self.signature = signature or ""  # type: ignore[assignment]

  /*else*/ {
    __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_signature); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 129, __pyx_L1_error)
    if (!__pyx_t_8) {
    } else {
      __Pyx_INCREF(__pyx_v_signature);
      __pyx_t_1 = __pyx_v_signature;
      goto __pyx_L6_bool_binop_done;
    }
    __Pyx_INCREF(__pyx_kp_u__5);
    __pyx_t_1 = __pyx_kp_u__5;
    __pyx_L6_bool_binop_done:;
    __Pyx_GIVEREF(__pyx_t_1);
    __Pyx_GOTREF(__pyx_v_self->signature);
    __Pyx_DECREF(__pyx_v_self->signature);
    __pyx_v_self->signature = __pyx_t_1;
    __pyx_t_1 = 0;

+130:             self.signature_tree = get_signature_tree(signature or "")

    __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_signature); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 130, __pyx_L1_error)
    if (!__pyx_t_8) {
    } else {
      __Pyx_INCREF(__pyx_v_signature);
      __pyx_t_4 = __pyx_v_signature;
      goto __pyx_L8_bool_binop_done;
    }
    __Pyx_INCREF(__pyx_kp_u__5);
    __pyx_t_4 = __pyx_kp_u__5;
    __pyx_L8_bool_binop_done:;
    __Pyx_INCREF(__pyx_v_9dbus_fast_7message_get_signature_tree);
    __pyx_t_2 = __pyx_v_9dbus_fast_7message_get_signature_tree; __pyx_t_5 = NULL;
    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
      __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2);
      if (likely(__pyx_t_5)) {
        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
        __Pyx_INCREF(__pyx_t_5);
        __Pyx_INCREF(function);
        __Pyx_DECREF_SET(__pyx_t_2, function);
      }
    }
    __pyx_t_1 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_5, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4);
    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 130, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_GIVEREF(__pyx_t_1);
    __Pyx_GOTREF(__pyx_v_self->signature_tree);
    __Pyx_DECREF(__pyx_v_self->signature_tree);
    __pyx_v_self->signature_tree = __pyx_t_1;
    __pyx_t_1 = 0;
  }
  __pyx_L5:;

+131:         self.body = body

  __Pyx_INCREF(__pyx_v_body);
  __Pyx_GIVEREF(__pyx_v_body);
  __Pyx_GOTREF(__pyx_v_self->body);
  __Pyx_DECREF(__pyx_v_self->body);
  __pyx_v_self->body = __pyx_v_body;

+132:         self.serial = serial or 0

  __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_serial); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 132, __pyx_L1_error)
  if (!__pyx_t_8) {
  } else {
    __pyx_t_7 = __Pyx_PyInt_As_unsigned_int(__pyx_v_serial); if (unlikely((__pyx_t_7 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 132, __pyx_L1_error)
    __pyx_t_6 = __pyx_t_7;
    goto __pyx_L10_bool_binop_done;
  }
  __pyx_t_6 = 0;
  __pyx_L10_bool_binop_done:;
  __pyx_v_self->serial = __pyx_t_6;

 133:

+134:         if not validate:

  __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_validate); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 134, __pyx_L1_error)
  __pyx_t_3 = ((!__pyx_t_8) != 0);
  if (__pyx_t_3) {
/* … */
  }

+135:             return

    __pyx_r = 0;
    goto __pyx_L0;

+136:         if self.destination is not None:

  __pyx_t_3 = (__pyx_v_self->destination != Py_None);
  __pyx_t_8 = (__pyx_t_3 != 0);
  if (__pyx_t_8) {
/* … */
  }

+137:             assert_bus_name_valid(self.destination)

    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_assert_bus_name_valid); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 137, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_4 = NULL;
    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
      if (likely(__pyx_t_4)) {
        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
        __Pyx_INCREF(__pyx_t_4);
        __Pyx_INCREF(function);
        __Pyx_DECREF_SET(__pyx_t_2, function);
      }
    }
    __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_v_self->destination) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_self->destination);
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 137, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+138:         if self.interface is not None:

  __pyx_t_8 = (__pyx_v_self->interface != Py_None);
  __pyx_t_3 = (__pyx_t_8 != 0);
  if (__pyx_t_3) {
/* … */
  }

+139:             assert_interface_name_valid(self.interface)

    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_assert_interface_name_valid); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 139, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_4 = NULL;
    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
      if (likely(__pyx_t_4)) {
        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
        __Pyx_INCREF(__pyx_t_4);
        __Pyx_INCREF(function);
        __Pyx_DECREF_SET(__pyx_t_2, function);
      }
    }
    __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_v_self->interface) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_self->interface);
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 139, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+140:         if self.path is not None:

  __pyx_t_3 = (__pyx_v_self->path != Py_None);
  __pyx_t_8 = (__pyx_t_3 != 0);
  if (__pyx_t_8) {
/* … */
  }

+141:             assert_object_path_valid(self.path)

    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_assert_object_path_valid); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 141, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_4 = NULL;
    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
      if (likely(__pyx_t_4)) {
        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
        __Pyx_INCREF(__pyx_t_4);
        __Pyx_INCREF(function);
        __Pyx_DECREF_SET(__pyx_t_2, function);
      }
    }
    __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_v_self->path) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_self->path);
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 141, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+142:         if self.member is not None:

  __pyx_t_8 = (__pyx_v_self->member != Py_None);
  __pyx_t_3 = (__pyx_t_8 != 0);
  if (__pyx_t_3) {
/* … */
  }

+143:             assert_member_name_valid(self.member)

    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_assert_member_name_valid); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 143, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_4 = NULL;
    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
      if (likely(__pyx_t_4)) {
        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
        __Pyx_INCREF(__pyx_t_4);
        __Pyx_INCREF(function);
        __Pyx_DECREF_SET(__pyx_t_2, function);
      }
    }
    __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_v_self->member) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_self->member);
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 143, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+144:         if self.error_name is not None:

  __pyx_t_3 = (__pyx_v_self->error_name != Py_None);
  __pyx_t_8 = (__pyx_t_3 != 0);
  if (__pyx_t_8) {
/* … */
  }

+145:             assert_interface_name_valid(self.error_name)  # type: ignore[arg-type]

    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_assert_interface_name_valid); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 145, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_4 = NULL;
    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
      if (likely(__pyx_t_4)) {
        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
        __Pyx_INCREF(__pyx_t_4);
        __Pyx_INCREF(function);
        __Pyx_DECREF_SET(__pyx_t_2, function);
      }
    }
    __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_v_self->error_name) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_self->error_name);
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 145, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 146:

+147:         required_fields = REQUIRED_FIELDS.get(self.message_type)

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_REQUIRED_FIELDS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 147, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_get); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 147, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4);
    if (likely(__pyx_t_2)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
      __Pyx_INCREF(__pyx_t_2);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_4, function);
    }
  }
  __pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_2, __pyx_v_self->message_type) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_self->message_type);
  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 147, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_v_required_fields = __pyx_t_1;
  __pyx_t_1 = 0;

+148:         if not required_fields:

  __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_required_fields); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 148, __pyx_L1_error)
  __pyx_t_3 = ((!__pyx_t_8) != 0);
  if (unlikely(__pyx_t_3)) {
/* … */
  }

+149:             raise InvalidMessageError(f"got unknown message type: {self.message_type}")

    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_InvalidMessageError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 149, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_self->message_type, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 149, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_5 = __Pyx_PyUnicode_Concat(__pyx_kp_u_got_unknown_message_type, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 149, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_2 = NULL;
    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
      __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4);
      if (likely(__pyx_t_2)) {
        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
        __Pyx_INCREF(__pyx_t_2);
        __Pyx_INCREF(function);
        __Pyx_DECREF_SET(__pyx_t_4, function);
      }
    }
    __pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_2, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5);
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 149, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_Raise(__pyx_t_1, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __PYX_ERR(0, 149, __pyx_L1_error)

+150:         for field in required_fields:

  if (likely(PyList_CheckExact(__pyx_v_required_fields)) || PyTuple_CheckExact(__pyx_v_required_fields)) {
    __pyx_t_1 = __pyx_v_required_fields; __Pyx_INCREF(__pyx_t_1); __pyx_t_9 = 0;
    __pyx_t_10 = NULL;
  } else {
    __pyx_t_9 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_required_fields); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 150, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_10 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 150, __pyx_L1_error)
  }
  for (;;) {
    if (likely(!__pyx_t_10)) {
      if (likely(PyList_CheckExact(__pyx_t_1))) {
        if (__pyx_t_9 >= PyList_GET_SIZE(__pyx_t_1)) break;
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_9); __Pyx_INCREF(__pyx_t_4); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 150, __pyx_L1_error)
        #else
        __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 150, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        #endif
      } else {
        if (__pyx_t_9 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_9); __Pyx_INCREF(__pyx_t_4); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 150, __pyx_L1_error)
        #else
        __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 150, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        #endif
      }
    } else {
      __pyx_t_4 = __pyx_t_10(__pyx_t_1);
      if (unlikely(!__pyx_t_4)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
          else __PYX_ERR(0, 150, __pyx_L1_error)
        }
        break;
      }
      __Pyx_GOTREF(__pyx_t_4);
    }
    __Pyx_XDECREF_SET(__pyx_v_field, __pyx_t_4);
    __pyx_t_4 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+151:             if not getattr(self, field):

    __pyx_t_4 = __Pyx_GetAttr(((PyObject *)__pyx_v_self), __pyx_v_field); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 151, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 151, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_8 = ((!__pyx_t_3) != 0);
    if (unlikely(__pyx_t_8)) {
/* … */
    }

+152:                 raise InvalidMessageError(f"missing required field: {field}")

      __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_InvalidMessageError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 152, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_field, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 152, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_11 = __Pyx_PyUnicode_Concat(__pyx_kp_u_missing_required_field, __pyx_t_2); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 152, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_11);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __pyx_t_2 = NULL;
      if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) {
        __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_5);
        if (likely(__pyx_t_2)) {
          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
          __Pyx_INCREF(__pyx_t_2);
          __Pyx_INCREF(function);
          __Pyx_DECREF_SET(__pyx_t_5, function);
        }
      }
      __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_2, __pyx_t_11) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_11);
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
      if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 152, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_Raise(__pyx_t_4, 0, 0, 0);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __PYX_ERR(0, 152, __pyx_L1_error)

 153:

+154:     @staticmethod

  __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_staticmethod, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 154, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (PyDict_SetItem((PyObject *)__pyx_ptype_9dbus_fast_7message_Message->tp_dict, __pyx_n_s_new_error, __pyx_t_1) < 0) __PYX_ERR(0, 155, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  PyType_Modified(__pyx_ptype_9dbus_fast_7message_Message);

+155:     def new_error(

/* Python wrapper */
static struct __pyx_obj_9dbus_fast_7message_Message *__pyx_pw_9dbus_fast_7message_7Message_3new_error(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_9dbus_fast_7message_7Message_2new_error[] = "A convenience constructor to create an error message in reply to the given message.\n\n        :param msg: The message this error is in reply to.\n        :type msg: :class:`Message`\n        :param error_name: The name of this error. Must be a valid interface name.\n        :type error_name: str\n        :param error_text: Human-readable text for the error.\n\n        :returns: The error message.\n        :rtype: :class:`Message`\n\n        :raises:\n            - :class:`InvalidInterfaceNameError` - If the error_name is not a valid interface name.\n        ";
static PyMethodDef __pyx_mdef_9dbus_fast_7message_7Message_3new_error = {"new_error", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9dbus_fast_7message_7Message_3new_error, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9dbus_fast_7message_7Message_2new_error};
static struct __pyx_obj_9dbus_fast_7message_Message *__pyx_pw_9dbus_fast_7message_7Message_3new_error(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct __pyx_obj_9dbus_fast_7message_Message *__pyx_v_msg = 0;
  PyObject *__pyx_v_error_name = 0;
  PyObject *__pyx_v_error_text = 0;
  struct __pyx_obj_9dbus_fast_7message_Message *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("new_error (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_msg,&__pyx_n_s_error_name,&__pyx_n_s_error_text,0};
    PyObject* values[3] = {0,0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_msg)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_error_name)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("new_error", 1, 3, 3, 1); __PYX_ERR(0, 155, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_error_text)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("new_error", 1, 3, 3, 2); __PYX_ERR(0, 155, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "new_error") < 0)) __PYX_ERR(0, 155, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
    }
    __pyx_v_msg = ((struct __pyx_obj_9dbus_fast_7message_Message *)values[0]);
    __pyx_v_error_name = values[1];
    __pyx_v_error_text = ((PyObject*)values[2]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("new_error", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 155, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("dbus_fast.message.Message.new_error", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_msg), __pyx_ptype_9dbus_fast_7message_Message, 1, "msg", 0))) __PYX_ERR(0, 156, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_error_text), (&PyUnicode_Type), 1, "error_text", 1))) __PYX_ERR(0, 156, __pyx_L1_error)
  __pyx_r = __pyx_pf_9dbus_fast_7message_7Message_2new_error(__pyx_v_msg, __pyx_v_error_name, __pyx_v_error_text);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static struct __pyx_obj_9dbus_fast_7message_Message *__pyx_pf_9dbus_fast_7message_7Message_2new_error(struct __pyx_obj_9dbus_fast_7message_Message *__pyx_v_msg, PyObject *__pyx_v_error_name, PyObject *__pyx_v_error_text) {
  struct __pyx_obj_9dbus_fast_7message_Message *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("new_error", 0);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("dbus_fast.message.Message.new_error", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF((PyObject *)__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__14 = PyTuple_Pack(3, __pyx_n_s_msg, __pyx_n_s_error_name, __pyx_n_s_error_text); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(0, 155, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__14);
  __Pyx_GIVEREF(__pyx_tuple__14);
/* … */
  __pyx_t_1 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 155, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_msg, __pyx_n_u_Message) < 0) __PYX_ERR(0, 155, __pyx_L1_error)
/* … */
  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9dbus_fast_7message_7Message_3new_error, __Pyx_CYFUNCTION_STATICMETHOD | __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Message_new_error, NULL, __pyx_n_s_dbus_fast_message, __pyx_d, ((PyObject *)__pyx_codeobj__15)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 155, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_1);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (PyDict_SetItem((PyObject *)__pyx_ptype_9dbus_fast_7message_Message->tp_dict, __pyx_n_s_new_error, __pyx_t_4) < 0) __PYX_ERR(0, 155, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  PyType_Modified(__pyx_ptype_9dbus_fast_7message_Message);
/* … */
  __Pyx_GetNameInClass(__pyx_t_4, (PyObject *)__pyx_ptype_9dbus_fast_7message_Message, __pyx_n_s_new_error); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 155, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_codeobj__15 = (PyObject*)__Pyx_PyCode_New(3, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__14, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_dbus_fast_message_py, __pyx_n_s_new_error, 155, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__15)) __PYX_ERR(0, 155, __pyx_L1_error)

+156:         msg: "Message", error_name: Union[str, ErrorType], error_text: str

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_Union); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 156, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 156, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_INCREF(((PyObject *)(&PyUnicode_Type)));
  __Pyx_GIVEREF(((PyObject *)(&PyUnicode_Type)));
  PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)(&PyUnicode_Type)));
  __Pyx_INCREF(__pyx_v_9dbus_fast_7message_ErrorType);
  __Pyx_GIVEREF(__pyx_v_9dbus_fast_7message_ErrorType);
  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_9dbus_fast_7message_ErrorType);
  __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 156, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_error_name, __pyx_t_4) < 0) __PYX_ERR(0, 155, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_error_text, __pyx_n_u_unicode) < 0) __PYX_ERR(0, 155, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_return, __pyx_n_u_Message) < 0) __PYX_ERR(0, 155, __pyx_L1_error)

 157:     ) -> "Message":

 158:         """A convenience constructor to create an error message in reply to the given message.

 159:

 160:         :param msg: The message this error is in reply to.

 161:         :type msg: :class:`Message`

 162:         :param error_name: The name of this error. Must be a valid interface name.

 163:         :type error_name: str

 164:         :param error_text: Human-readable text for the error.

 165:

 166:         :returns: The error message.

 167:         :rtype: :class:`Message`

 168:

 169:         :raises:

 170:             - :class:`InvalidInterfaceNameError` - If the error_name is not a valid interface name.

 171:         """

+172:         return Message(

  __Pyx_XDECREF(((PyObject *)__pyx_r));
/* … */
  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_9dbus_fast_7message_Message), __pyx_empty_tuple, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 172, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_r = ((struct __pyx_obj_9dbus_fast_7message_Message *)__pyx_t_2);
  __pyx_t_2 = 0;
  goto __pyx_L0;

+173:             message_type=MessageType.ERROR,

  __pyx_t_1 = __Pyx_PyDict_NewPresized(6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 173, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_9dbus_fast_7message_MessageType, __pyx_n_s_ERROR); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 173, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_message_type, __pyx_t_2) < 0) __PYX_ERR(0, 173, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+174:             reply_serial=msg.serial,

  __pyx_t_2 = __Pyx_PyInt_From_unsigned_int(__pyx_v_msg->serial); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 174, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_reply_serial, __pyx_t_2) < 0) __PYX_ERR(0, 173, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+175:             destination=msg.sender,

  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_destination, __pyx_v_msg->sender) < 0) __PYX_ERR(0, 173, __pyx_L1_error)

+176:             error_name=error_name,

  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_error_name, __pyx_v_error_name) < 0) __PYX_ERR(0, 173, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_signature, __pyx_n_u_s) < 0) __PYX_ERR(0, 173, __pyx_L1_error)

 177:             signature="s",

+178:             body=[error_text],

  __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 178, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_INCREF(__pyx_v_error_text);
  __Pyx_GIVEREF(__pyx_v_error_text);
  PyList_SET_ITEM(__pyx_t_2, 0, __pyx_v_error_text);
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_body, __pyx_t_2) < 0) __PYX_ERR(0, 173, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 179:         )

 180:

+181:     @staticmethod

  __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_staticmethod, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 181, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (PyDict_SetItem((PyObject *)__pyx_ptype_9dbus_fast_7message_Message->tp_dict, __pyx_n_s_new_method_return, __pyx_t_1) < 0) __PYX_ERR(0, 182, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  PyType_Modified(__pyx_ptype_9dbus_fast_7message_Message);

+182:     def new_method_return(

/* Python wrapper */
static struct __pyx_obj_9dbus_fast_7message_Message *__pyx_pw_9dbus_fast_7message_7Message_5new_method_return(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_9dbus_fast_7message_7Message_4new_method_return[] = "A convenience constructor to create a method return to the given method call message.\n\n        :param msg: The method call message this is a reply to.\n        :type msg: :class:`Message`\n        :param signature: The signature for the message body.\n        :type signature: str\n        :param body: The body of this message. Must match the signature.\n        :type body: list(Any)\n        :param unix_fds: List integer file descriptors to send with this message.\n        :type body: list(int)\n\n        :returns: The method return message\n        :rtype: :class:`Message`\n\n        :raises:\n            - :class:`InvalidSignatureError` - If the signature is not a valid signature.\n        ";
static PyMethodDef __pyx_mdef_9dbus_fast_7message_7Message_5new_method_return = {"new_method_return", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9dbus_fast_7message_7Message_5new_method_return, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9dbus_fast_7message_7Message_4new_method_return};
static struct __pyx_obj_9dbus_fast_7message_Message *__pyx_pw_9dbus_fast_7message_7Message_5new_method_return(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct __pyx_obj_9dbus_fast_7message_Message *__pyx_v_msg = 0;
  PyObject *__pyx_v_signature = 0;
  PyObject *__pyx_v_body = 0;
  PyObject *__pyx_v_unix_fds = 0;
  struct __pyx_obj_9dbus_fast_7message_Message *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("new_method_return (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_msg,&__pyx_n_s_signature,&__pyx_n_s_body,&__pyx_n_s_unix_fds,0};
    PyObject* values[4] = {0,0,0,0};
    values[1] = ((PyObject*)__pyx_kp_u__5);
    values[2] = __pyx_k__6;
    values[3] = __pyx_k__7;
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_msg)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_signature);
          if (value) { values[1] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_body);
          if (value) { values[2] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  3:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_unix_fds);
          if (value) { values[3] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "new_method_return") < 0)) __PYX_ERR(0, 182, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_msg = ((struct __pyx_obj_9dbus_fast_7message_Message *)values[0]);
    __pyx_v_signature = ((PyObject*)values[1]);
    __pyx_v_body = values[2];
    __pyx_v_unix_fds = values[3];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("new_method_return", 0, 1, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 182, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("dbus_fast.message.Message.new_method_return", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_msg), __pyx_ptype_9dbus_fast_7message_Message, 1, "msg", 0))) __PYX_ERR(0, 183, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_signature), (&PyUnicode_Type), 1, "signature", 1))) __PYX_ERR(0, 184, __pyx_L1_error)
  __pyx_r = __pyx_pf_9dbus_fast_7message_7Message_4new_method_return(__pyx_v_msg, __pyx_v_signature, __pyx_v_body, __pyx_v_unix_fds);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static struct __pyx_obj_9dbus_fast_7message_Message *__pyx_pf_9dbus_fast_7message_7Message_4new_method_return(struct __pyx_obj_9dbus_fast_7message_Message *__pyx_v_msg, PyObject *__pyx_v_signature, PyObject *__pyx_v_body, PyObject *__pyx_v_unix_fds) {
  struct __pyx_obj_9dbus_fast_7message_Message *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("new_method_return", 0);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("dbus_fast.message.Message.new_method_return", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF((PyObject *)__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__16 = PyTuple_Pack(4, __pyx_n_s_msg, __pyx_n_s_signature, __pyx_n_s_body, __pyx_n_s_unix_fds); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(0, 182, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__16);
  __Pyx_GIVEREF(__pyx_tuple__16);
/* … */
  __pyx_t_1 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 182, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_msg, __pyx_n_u_Message) < 0) __PYX_ERR(0, 182, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_signature, __pyx_n_u_unicode) < 0) __PYX_ERR(0, 182, __pyx_L1_error)
/* … */
  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9dbus_fast_7message_7Message_5new_method_return, __Pyx_CYFUNCTION_STATICMETHOD | __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Message_new_method_return, NULL, __pyx_n_s_dbus_fast_message, __pyx_d, ((PyObject *)__pyx_codeobj__17)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 182, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_3, __pyx_t_1);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (PyDict_SetItem((PyObject *)__pyx_ptype_9dbus_fast_7message_Message->tp_dict, __pyx_n_s_new_method_return, __pyx_t_3) < 0) __PYX_ERR(0, 182, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  PyType_Modified(__pyx_ptype_9dbus_fast_7message_Message);
/* … */
  __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_9dbus_fast_7message_Message, __pyx_n_s_new_method_return); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 182, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_codeobj__17 = (PyObject*)__Pyx_PyCode_New(4, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__16, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_dbus_fast_message_py, __pyx_n_s_new_method_return, 182, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__17)) __PYX_ERR(0, 182, __pyx_L1_error)

 183:         msg: "Message",

 184:         signature: str = "",

+185:         body: List[Any] = [],

  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 185, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_k__6 = __pyx_t_1;
  __Pyx_GIVEREF(__pyx_t_1);
  __pyx_t_1 = 0;
/* … */
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_List); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 185, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_Any); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 185, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 185, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_body, __pyx_t_2) < 0) __PYX_ERR(0, 182, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+186:         unix_fds: List[int] = [],

  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 186, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_k__7 = __pyx_t_1;
  __Pyx_GIVEREF(__pyx_t_1);
  __pyx_t_1 = 0;
/* … */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_List); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 186, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_t_2, ((PyObject *)(&PyInt_Type))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 186, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_unix_fds, __pyx_t_3) < 0) __PYX_ERR(0, 182, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_return, __pyx_n_u_Message) < 0) __PYX_ERR(0, 182, __pyx_L1_error)

 187:     ) -> "Message":

 188:         """A convenience constructor to create a method return to the given method call message.

 189:

 190:         :param msg: The method call message this is a reply to.

 191:         :type msg: :class:`Message`

 192:         :param signature: The signature for the message body.

 193:         :type signature: str

 194:         :param body: The body of this message. Must match the signature.

 195:         :type body: list(Any)

 196:         :param unix_fds: List integer file descriptors to send with this message.

 197:         :type body: list(int)

 198:

 199:         :returns: The method return message

 200:         :rtype: :class:`Message`

 201:

 202:         :raises:

 203:             - :class:`InvalidSignatureError` - If the signature is not a valid signature.

 204:         """

+205:         return Message(

  __Pyx_XDECREF(((PyObject *)__pyx_r));
/* … */
  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_9dbus_fast_7message_Message), __pyx_empty_tuple, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 205, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_r = ((struct __pyx_obj_9dbus_fast_7message_Message *)__pyx_t_2);
  __pyx_t_2 = 0;
  goto __pyx_L0;

+206:             message_type=MessageType.METHOD_RETURN,

  __pyx_t_1 = __Pyx_PyDict_NewPresized(6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 206, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_9dbus_fast_7message_MessageType, __pyx_n_s_METHOD_RETURN); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 206, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_message_type, __pyx_t_2) < 0) __PYX_ERR(0, 206, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+207:             reply_serial=msg.serial,

  __pyx_t_2 = __Pyx_PyInt_From_unsigned_int(__pyx_v_msg->serial); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 207, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_reply_serial, __pyx_t_2) < 0) __PYX_ERR(0, 206, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+208:             destination=msg.sender,

  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_destination, __pyx_v_msg->sender) < 0) __PYX_ERR(0, 206, __pyx_L1_error)

+209:             signature=signature,

  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_signature, __pyx_v_signature) < 0) __PYX_ERR(0, 206, __pyx_L1_error)

+210:             body=body,

  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_body, __pyx_v_body) < 0) __PYX_ERR(0, 206, __pyx_L1_error)

+211:             unix_fds=unix_fds,

  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_unix_fds, __pyx_v_unix_fds) < 0) __PYX_ERR(0, 206, __pyx_L1_error)

 212:         )

 213:

+214:     @staticmethod

  __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_staticmethod, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 214, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  if (PyDict_SetItem((PyObject *)__pyx_ptype_9dbus_fast_7message_Message->tp_dict, __pyx_n_s_new_signal, __pyx_t_1) < 0) __PYX_ERR(0, 215, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  PyType_Modified(__pyx_ptype_9dbus_fast_7message_Message);

+215:     def new_signal(

/* Python wrapper */
static struct __pyx_obj_9dbus_fast_7message_Message *__pyx_pw_9dbus_fast_7message_7Message_7new_signal(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_9dbus_fast_7message_7Message_6new_signal[] = "A convenience constructor to create a new signal message.\n\n        :param path: The path of this signal.\n        :type path: str\n        :param interface: The interface of this signal.\n        :type interface: str\n        :param member: The member name of this signal.\n        :type member: str\n        :param signature: The signature of the signal body.\n        :type signature: str\n        :param body: The body of this signal message.\n        :type body: list(Any)\n        :param unix_fds: List integer file descriptors to send with this message.\n        :type body: list(int)\n\n        :returns: The signal message.\n        :rtype: :class:`Message`\n\n        :raises:\n            - :class:`InvalidSignatureError` - If the signature is not a valid signature.\n            - :class:`InvalidObjectPathError` - If ``path`` is not a valid object path.\n            - :class:`InvalidInterfaceNameError` - If ``interface`` is not a valid interface name.\n            - :class:`InvalidMemberNameError` - If ``member`` is not a valid member name.\n        ";
static PyMethodDef __pyx_mdef_9dbus_fast_7message_7Message_7new_signal = {"new_signal", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9dbus_fast_7message_7Message_7new_signal, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9dbus_fast_7message_7Message_6new_signal};
static struct __pyx_obj_9dbus_fast_7message_Message *__pyx_pw_9dbus_fast_7message_7Message_7new_signal(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_path = 0;
  PyObject *__pyx_v_interface = 0;
  PyObject *__pyx_v_member = 0;
  PyObject *__pyx_v_signature = 0;
  PyObject *__pyx_v_body = 0;
  PyObject *__pyx_v_unix_fds = 0;
  struct __pyx_obj_9dbus_fast_7message_Message *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("new_signal (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_path,&__pyx_n_s_interface,&__pyx_n_s_member,&__pyx_n_s_signature,&__pyx_n_s_body,&__pyx_n_s_unix_fds,0};
    PyObject* values[6] = {0,0,0,0,0,0};
    values[3] = ((PyObject*)__pyx_kp_u__5);
/* … */
  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static struct __pyx_obj_9dbus_fast_7message_Message *__pyx_pf_9dbus_fast_7message_7Message_6new_signal(PyObject *__pyx_v_path, PyObject *__pyx_v_interface, PyObject *__pyx_v_member, PyObject *__pyx_v_signature, PyObject *__pyx_v_body, PyObject *__pyx_v_unix_fds) {
  struct __pyx_obj_9dbus_fast_7message_Message *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("new_signal", 0);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("dbus_fast.message.Message.new_signal", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF((PyObject *)__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__18 = PyTuple_Pack(6, __pyx_n_s_path, __pyx_n_s_interface, __pyx_n_s_member, __pyx_n_s_signature, __pyx_n_s_body, __pyx_n_s_unix_fds); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(0, 215, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__18);
  __Pyx_GIVEREF(__pyx_tuple__18);
/* … */
  __pyx_t_1 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 215, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_path, __pyx_n_u_unicode) < 0) __PYX_ERR(0, 215, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_interface, __pyx_n_u_unicode) < 0) __PYX_ERR(0, 215, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_member, __pyx_n_u_unicode) < 0) __PYX_ERR(0, 215, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_signature, __pyx_n_u_unicode) < 0) __PYX_ERR(0, 215, __pyx_L1_error)
/* … */
  __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_9dbus_fast_7message_7Message_7new_signal, __Pyx_CYFUNCTION_STATICMETHOD | __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Message_new_signal, NULL, __pyx_n_s_dbus_fast_message, __pyx_d, ((PyObject *)__pyx_codeobj__19)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 215, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_5, __pyx_t_1);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (PyDict_SetItem((PyObject *)__pyx_ptype_9dbus_fast_7message_Message->tp_dict, __pyx_n_s_new_signal, __pyx_t_5) < 0) __PYX_ERR(0, 215, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  PyType_Modified(__pyx_ptype_9dbus_fast_7message_Message);
/* … */
  __Pyx_GetNameInClass(__pyx_t_5, (PyObject *)__pyx_ptype_9dbus_fast_7message_Message, __pyx_n_s_new_signal); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 215, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_codeobj__19 = (PyObject*)__Pyx_PyCode_New(6, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__18, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_dbus_fast_message_py, __pyx_n_s_new_signal, 215, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__19)) __PYX_ERR(0, 215, __pyx_L1_error)

 216:         path: str,

 217:         interface: str,

 218:         member: str,

 219:         signature: str = "",

+220:         body: Optional[List[Any]] = None,

    values[4] = ((PyObject *)Py_None);
/* … */
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_Optional); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 220, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_List); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 220, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_Any); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 220, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 220, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 220, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_body, __pyx_t_4) < 0) __PYX_ERR(0, 215, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+221:         unix_fds: Optional[List[int]] = None,

    values[5] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
        CYTHON_FALLTHROUGH;
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        CYTHON_FALLTHROUGH;
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_path)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_interface)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("new_signal", 0, 3, 6, 1); __PYX_ERR(0, 215, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_member)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("new_signal", 0, 3, 6, 2); __PYX_ERR(0, 215, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  3:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_signature);
          if (value) { values[3] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  4:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_body);
          if (value) { values[4] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  5:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_unix_fds);
          if (value) { values[5] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "new_signal") < 0)) __PYX_ERR(0, 215, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
        CYTHON_FALLTHROUGH;
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        CYTHON_FALLTHROUGH;
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_path = ((PyObject*)values[0]);
    __pyx_v_interface = ((PyObject*)values[1]);
    __pyx_v_member = ((PyObject*)values[2]);
    __pyx_v_signature = ((PyObject*)values[3]);
    __pyx_v_body = values[4];
    __pyx_v_unix_fds = values[5];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("new_signal", 0, 3, 6, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 215, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("dbus_fast.message.Message.new_signal", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_path), (&PyUnicode_Type), 1, "path", 1))) __PYX_ERR(0, 216, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_interface), (&PyUnicode_Type), 1, "interface", 1))) __PYX_ERR(0, 217, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_member), (&PyUnicode_Type), 1, "member", 1))) __PYX_ERR(0, 218, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_signature), (&PyUnicode_Type), 1, "signature", 1))) __PYX_ERR(0, 219, __pyx_L1_error)
  __pyx_r = __pyx_pf_9dbus_fast_7message_7Message_6new_signal(__pyx_v_path, __pyx_v_interface, __pyx_v_member, __pyx_v_signature, __pyx_v_body, __pyx_v_unix_fds);
/* … */
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_Optional); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 221, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_List); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 221, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_t_5, ((PyObject *)(&PyInt_Type))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 221, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 221, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_unix_fds, __pyx_t_5) < 0) __PYX_ERR(0, 215, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_return, __pyx_n_u_Message) < 0) __PYX_ERR(0, 215, __pyx_L1_error)

 222:     ) -> "Message":

 223:         """A convenience constructor to create a new signal message.

 224:

 225:         :param path: The path of this signal.

 226:         :type path: str

 227:         :param interface: The interface of this signal.

 228:         :type interface: str

 229:         :param member: The member name of this signal.

 230:         :type member: str

 231:         :param signature: The signature of the signal body.

 232:         :type signature: str

 233:         :param body: The body of this signal message.

 234:         :type body: list(Any)

 235:         :param unix_fds: List integer file descriptors to send with this message.

 236:         :type body: list(int)

 237:

 238:         :returns: The signal message.

 239:         :rtype: :class:`Message`

 240:

 241:         :raises:

 242:             - :class:`InvalidSignatureError` - If the signature is not a valid signature.

 243:             - :class:`InvalidObjectPathError` - If ``path`` is not a valid object path.

 244:             - :class:`InvalidInterfaceNameError` - If ``interface`` is not a valid interface name.

 245:             - :class:`InvalidMemberNameError` - If ``member`` is not a valid member name.

 246:         """

+247:         return Message(

  __Pyx_XDECREF(((PyObject *)__pyx_r));
/* … */
  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_9dbus_fast_7message_Message), __pyx_empty_tuple, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 247, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_r = ((struct __pyx_obj_9dbus_fast_7message_Message *)__pyx_t_2);
  __pyx_t_2 = 0;
  goto __pyx_L0;

+248:             message_type=MessageType.SIGNAL,

  __pyx_t_1 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 248, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_9dbus_fast_7message_MessageType, __pyx_n_s_SIGNAL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 248, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_message_type, __pyx_t_2) < 0) __PYX_ERR(0, 248, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+249:             interface=interface,

  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_interface, __pyx_v_interface) < 0) __PYX_ERR(0, 248, __pyx_L1_error)

+250:             path=path,

  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_path, __pyx_v_path) < 0) __PYX_ERR(0, 248, __pyx_L1_error)

+251:             member=member,

  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_member, __pyx_v_member) < 0) __PYX_ERR(0, 248, __pyx_L1_error)

+252:             signature=signature,

  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_signature, __pyx_v_signature) < 0) __PYX_ERR(0, 248, __pyx_L1_error)

+253:             body=body or [],

  __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_body); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 253, __pyx_L1_error)
  if (!__pyx_t_3) {
  } else {
    __Pyx_INCREF(__pyx_v_body);
    __pyx_t_2 = __pyx_v_body;
    goto __pyx_L3_bool_binop_done;
  }
  __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 253, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_INCREF(__pyx_t_4);
  __pyx_t_2 = __pyx_t_4;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_L3_bool_binop_done:;
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_body, __pyx_t_2) < 0) __PYX_ERR(0, 248, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+254:             unix_fds=unix_fds or [],

  __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_unix_fds); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 254, __pyx_L1_error)
  if (!__pyx_t_3) {
  } else {
    __Pyx_INCREF(__pyx_v_unix_fds);
    __pyx_t_2 = __pyx_v_unix_fds;
    goto __pyx_L5_bool_binop_done;
  }
  __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 254, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_INCREF(__pyx_t_4);
  __pyx_t_2 = __pyx_t_4;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_L5_bool_binop_done:;
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_unix_fds, __pyx_t_2) < 0) __PYX_ERR(0, 248, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 255:         )

 256:

+257:     def _marshall(self, negotiate_unix_fd: bool) -> bytearray:

static PyObject *__pyx_pw_9dbus_fast_7message_7Message_9_marshall(PyObject *__pyx_v_self, PyObject *__pyx_arg_negotiate_unix_fd); /*proto*/
static PyObject *__pyx_f_9dbus_fast_7message_7Message__marshall(struct __pyx_obj_9dbus_fast_7message_Message *__pyx_v_self, int __pyx_v_negotiate_unix_fd, int __pyx_skip_dispatch) {
  PyObject *__pyx_v_body_block = NULL;
  PyObject *__pyx_v_fields = NULL;
  PyObject *__pyx_v_header_body = NULL;
  PyObject *__pyx_v_header_block = NULL;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_marshall", 0);
  /* Check if called by wrapper */
  if (unlikely(__pyx_skip_dispatch)) ;
  /* Check if overridden in Python */
  else if (unlikely((Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) {
    #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS
    static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT;
    if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) {
      PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self));
      #endif
      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_marshall); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 257, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9dbus_fast_7message_7Message_9_marshall)) {
        __Pyx_XDECREF(__pyx_r);
        __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_v_negotiate_unix_fd); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 257, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_INCREF(__pyx_t_1);
        __pyx_t_4 = __pyx_t_1; __pyx_t_5 = NULL;
        if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
          __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
          if (likely(__pyx_t_5)) {
            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
            __Pyx_INCREF(__pyx_t_5);
            __Pyx_INCREF(function);
            __Pyx_DECREF_SET(__pyx_t_4, function);
          }
        }
        __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3);
        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 257, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __pyx_r = __pyx_t_2;
        __pyx_t_2 = 0;
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        goto __pyx_L0;
      }
      #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS
      __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self));
      __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self));
      if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) {
        __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT;
      }
      #endif
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS
    }
    #endif
  }
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("dbus_fast.message.Message._marshall", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_body_block);
  __Pyx_XDECREF(__pyx_v_fields);
  __Pyx_XDECREF(__pyx_v_header_body);
  __Pyx_XDECREF(__pyx_v_header_block);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static PyObject *__pyx_pw_9dbus_fast_7message_7Message_9_marshall(PyObject *__pyx_v_self, PyObject *__pyx_arg_negotiate_unix_fd); /*proto*/
static char __pyx_doc_9dbus_fast_7message_7Message_8_marshall[] = "Marshall this message into a byte array.";
static PyMethodDef __pyx_mdef_9dbus_fast_7message_7Message_9_marshall = {"_marshall", (PyCFunction)__pyx_pw_9dbus_fast_7message_7Message_9_marshall, METH_O, __pyx_doc_9dbus_fast_7message_7Message_8_marshall};
static PyObject *__pyx_pw_9dbus_fast_7message_7Message_9_marshall(PyObject *__pyx_v_self, PyObject *__pyx_arg_negotiate_unix_fd) {
  int __pyx_v_negotiate_unix_fd;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_marshall (wrapper)", 0);
  assert(__pyx_arg_negotiate_unix_fd); {
    __pyx_v_negotiate_unix_fd = __Pyx_PyObject_IsTrue(__pyx_arg_negotiate_unix_fd); if (unlikely((__pyx_v_negotiate_unix_fd == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 257, __pyx_L3_error)
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  __Pyx_AddTraceback("dbus_fast.message.Message._marshall", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9dbus_fast_7message_7Message_8_marshall(((struct __pyx_obj_9dbus_fast_7message_Message *)__pyx_v_self), ((int)__pyx_v_negotiate_unix_fd));
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9dbus_fast_7message_7Message_8_marshall(struct __pyx_obj_9dbus_fast_7message_Message *__pyx_v_self, int __pyx_v_negotiate_unix_fd) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_marshall", 0);
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __pyx_f_9dbus_fast_7message_7Message__marshall(__pyx_v_self, __pyx_v_negotiate_unix_fd, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 257, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("dbus_fast.message.Message._marshall", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__20 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_negotiate_unix_fd, __pyx_n_s_negotiate_unix_fd); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(0, 257, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__20);
  __Pyx_GIVEREF(__pyx_tuple__20);
/* … */
  __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 257, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_negotiate_unix_fd, ((PyObject*)&PyBool_Type)) < 0) __PYX_ERR(0, 257, __pyx_L1_error)
  __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_9dbus_fast_7message_7Message_9_marshall, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Message__marshall, NULL, __pyx_n_s_dbus_fast_message, __pyx_d, ((PyObject *)__pyx_codeobj__21)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 257, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_5, __pyx_t_1);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (PyDict_SetItem((PyObject *)__pyx_ptype_9dbus_fast_7message_Message->tp_dict, __pyx_n_s_marshall, __pyx_t_5) < 0) __PYX_ERR(0, 257, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  PyType_Modified(__pyx_ptype_9dbus_fast_7message_Message);
  __pyx_codeobj__21 = (PyObject*)__Pyx_PyCode_New(2, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__20, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_dbus_fast_message_py, __pyx_n_s_marshall, 257, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__21)) __PYX_ERR(0, 257, __pyx_L1_error)

 258:         """Marshall this message into a byte array."""

 259:         # TODO maximum message size is 134217728 (128 MiB)

+260:         body_block = Marshaller(self.signature, self.body)

  __Pyx_INCREF(__pyx_v_9dbus_fast_7message_Marshaller);
  __pyx_t_2 = __pyx_v_9dbus_fast_7message_Marshaller; __pyx_t_4 = NULL;
  __pyx_t_6 = 0;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_4)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
      __pyx_t_6 = 1;
    }
  }
  #if CYTHON_FAST_PYCALL
  if (PyFunction_Check(__pyx_t_2)) {
    PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_v_self->signature, __pyx_v_self->body};
    __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 260, __pyx_L1_error)
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_GOTREF(__pyx_t_1);
  } else
  #endif
  #if CYTHON_FAST_PYCCALL
  if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
    PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_v_self->signature, __pyx_v_self->body};
    __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 260, __pyx_L1_error)
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_GOTREF(__pyx_t_1);
  } else
  #endif
  {
    __pyx_t_3 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 260, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    if (__pyx_t_4) {
      __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); __pyx_t_4 = NULL;
    }
    __Pyx_INCREF(__pyx_v_self->signature);
    __Pyx_GIVEREF(__pyx_v_self->signature);
    PyTuple_SET_ITEM(__pyx_t_3, 0+__pyx_t_6, __pyx_v_self->signature);
    __Pyx_INCREF(__pyx_v_self->body);
    __Pyx_GIVEREF(__pyx_v_self->body);
    PyTuple_SET_ITEM(__pyx_t_3, 1+__pyx_t_6, __pyx_v_self->body);
    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 260, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_body_block = __pyx_t_1;
  __pyx_t_1 = 0;

+261:         body_block.marshall()

  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_body_block, __pyx_n_s_marshall_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 261, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 261, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 262:

+263:         fields = []

  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 263, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_fields = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

 264:

 265:         # No verify here since the marshaller will raise an exception if the

 266:         # Variant is invalid.

 267:

+268:         if self.path:

  __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_self->path); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 268, __pyx_L1_error)
  if (__pyx_t_7) {
/* … */
  }

+269:             fields.append([HEADER_PATH, Variant("o", self.path, False)])

    __Pyx_INCREF(__pyx_v_9dbus_fast_7message_Variant);
    __pyx_t_2 = __pyx_v_9dbus_fast_7message_Variant; __pyx_t_3 = NULL;
    __pyx_t_6 = 0;
    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
      if (likely(__pyx_t_3)) {
        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
        __Pyx_INCREF(__pyx_t_3);
        __Pyx_INCREF(function);
        __Pyx_DECREF_SET(__pyx_t_2, function);
        __pyx_t_6 = 1;
      }
    }
    #if CYTHON_FAST_PYCALL
    if (PyFunction_Check(__pyx_t_2)) {
      PyObject *__pyx_temp[4] = {__pyx_t_3, __pyx_n_u_o, __pyx_v_self->path, Py_False};
      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 3+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 269, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_GOTREF(__pyx_t_1);
    } else
    #endif
    #if CYTHON_FAST_PYCCALL
    if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
      PyObject *__pyx_temp[4] = {__pyx_t_3, __pyx_n_u_o, __pyx_v_self->path, Py_False};
      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 3+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 269, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_GOTREF(__pyx_t_1);
    } else
    #endif
    {
      __pyx_t_4 = PyTuple_New(3+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 269, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      if (__pyx_t_3) {
        __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __pyx_t_3 = NULL;
      }
      __Pyx_INCREF(__pyx_n_u_o);
      __Pyx_GIVEREF(__pyx_n_u_o);
      PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_6, __pyx_n_u_o);
      __Pyx_INCREF(__pyx_v_self->path);
      __Pyx_GIVEREF(__pyx_v_self->path);
      PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_6, __pyx_v_self->path);
      __Pyx_INCREF(Py_False);
      __Pyx_GIVEREF(Py_False);
      PyTuple_SET_ITEM(__pyx_t_4, 2+__pyx_t_6, Py_False);
      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 269, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    }
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_2 = PyList_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 269, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_INCREF(__pyx_v_9dbus_fast_7message_HEADER_PATH);
    __Pyx_GIVEREF(__pyx_v_9dbus_fast_7message_HEADER_PATH);
    PyList_SET_ITEM(__pyx_t_2, 0, __pyx_v_9dbus_fast_7message_HEADER_PATH);
    __Pyx_GIVEREF(__pyx_t_1);
    PyList_SET_ITEM(__pyx_t_2, 1, __pyx_t_1);
    __pyx_t_1 = 0;
    __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_fields, __pyx_t_2); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(0, 269, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+270:         if self.interface:

  __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_self->interface); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 270, __pyx_L1_error)
  if (__pyx_t_7) {
/* … */
  }

+271:             fields.append([HEADER_INTERFACE, Variant("s", self.interface, False)])

    __Pyx_INCREF(__pyx_v_9dbus_fast_7message_Variant);
    __pyx_t_1 = __pyx_v_9dbus_fast_7message_Variant; __pyx_t_4 = NULL;
    __pyx_t_6 = 0;
    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1);
      if (likely(__pyx_t_4)) {
        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
        __Pyx_INCREF(__pyx_t_4);
        __Pyx_INCREF(function);
        __Pyx_DECREF_SET(__pyx_t_1, function);
        __pyx_t_6 = 1;
      }
    }
    #if CYTHON_FAST_PYCALL
    if (PyFunction_Check(__pyx_t_1)) {
      PyObject *__pyx_temp[4] = {__pyx_t_4, __pyx_n_u_s, __pyx_v_self->interface, Py_False};
      __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 3+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 271, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_GOTREF(__pyx_t_2);
    } else
    #endif
    #if CYTHON_FAST_PYCCALL
    if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) {
      PyObject *__pyx_temp[4] = {__pyx_t_4, __pyx_n_u_s, __pyx_v_self->interface, Py_False};
      __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 3+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 271, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_GOTREF(__pyx_t_2);
    } else
    #endif
    {
      __pyx_t_3 = PyTuple_New(3+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 271, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      if (__pyx_t_4) {
        __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); __pyx_t_4 = NULL;
      }
      __Pyx_INCREF(__pyx_n_u_s);
      __Pyx_GIVEREF(__pyx_n_u_s);
      PyTuple_SET_ITEM(__pyx_t_3, 0+__pyx_t_6, __pyx_n_u_s);
      __Pyx_INCREF(__pyx_v_self->interface);
      __Pyx_GIVEREF(__pyx_v_self->interface);
      PyTuple_SET_ITEM(__pyx_t_3, 1+__pyx_t_6, __pyx_v_self->interface);
      __Pyx_INCREF(Py_False);
      __Pyx_GIVEREF(Py_False);
      PyTuple_SET_ITEM(__pyx_t_3, 2+__pyx_t_6, Py_False);
      __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 271, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    }
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_1 = PyList_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 271, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_INCREF(__pyx_v_9dbus_fast_7message_HEADER_INTERFACE);
    __Pyx_GIVEREF(__pyx_v_9dbus_fast_7message_HEADER_INTERFACE);
    PyList_SET_ITEM(__pyx_t_1, 0, __pyx_v_9dbus_fast_7message_HEADER_INTERFACE);
    __Pyx_GIVEREF(__pyx_t_2);
    PyList_SET_ITEM(__pyx_t_1, 1, __pyx_t_2);
    __pyx_t_2 = 0;
    __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_fields, __pyx_t_1); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(0, 271, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+272:         if self.member:

  __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_self->member); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 272, __pyx_L1_error)
  if (__pyx_t_7) {
/* … */
  }

+273:             fields.append([HEADER_MEMBER, Variant("s", self.member, False)])

    __Pyx_INCREF(__pyx_v_9dbus_fast_7message_Variant);
    __pyx_t_2 = __pyx_v_9dbus_fast_7message_Variant; __pyx_t_3 = NULL;
    __pyx_t_6 = 0;
    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
      if (likely(__pyx_t_3)) {
        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
        __Pyx_INCREF(__pyx_t_3);
        __Pyx_INCREF(function);
        __Pyx_DECREF_SET(__pyx_t_2, function);
        __pyx_t_6 = 1;
      }
    }
    #if CYTHON_FAST_PYCALL
    if (PyFunction_Check(__pyx_t_2)) {
      PyObject *__pyx_temp[4] = {__pyx_t_3, __pyx_n_u_s, __pyx_v_self->member, Py_False};
      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 3+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 273, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_GOTREF(__pyx_t_1);
    } else
    #endif
    #if CYTHON_FAST_PYCCALL
    if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
      PyObject *__pyx_temp[4] = {__pyx_t_3, __pyx_n_u_s, __pyx_v_self->member, Py_False};
      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 3+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 273, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_GOTREF(__pyx_t_1);
    } else
    #endif
    {
      __pyx_t_4 = PyTuple_New(3+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 273, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      if (__pyx_t_3) {
        __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __pyx_t_3 = NULL;
      }
      __Pyx_INCREF(__pyx_n_u_s);
      __Pyx_GIVEREF(__pyx_n_u_s);
      PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_6, __pyx_n_u_s);
      __Pyx_INCREF(__pyx_v_self->member);
      __Pyx_GIVEREF(__pyx_v_self->member);
      PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_6, __pyx_v_self->member);
      __Pyx_INCREF(Py_False);
      __Pyx_GIVEREF(Py_False);
      PyTuple_SET_ITEM(__pyx_t_4, 2+__pyx_t_6, Py_False);
      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 273, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    }
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_2 = PyList_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 273, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_INCREF(__pyx_v_9dbus_fast_7message_HEADER_MEMBER);
    __Pyx_GIVEREF(__pyx_v_9dbus_fast_7message_HEADER_MEMBER);
    PyList_SET_ITEM(__pyx_t_2, 0, __pyx_v_9dbus_fast_7message_HEADER_MEMBER);
    __Pyx_GIVEREF(__pyx_t_1);
    PyList_SET_ITEM(__pyx_t_2, 1, __pyx_t_1);
    __pyx_t_1 = 0;
    __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_fields, __pyx_t_2); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(0, 273, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+274:         if self.error_name:

  __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_self->error_name); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 274, __pyx_L1_error)
  if (__pyx_t_7) {
/* … */
  }

+275:             fields.append([HEADER_ERROR_NAME, Variant("s", self.error_name, False)])

    __Pyx_INCREF(__pyx_v_9dbus_fast_7message_Variant);
    __pyx_t_1 = __pyx_v_9dbus_fast_7message_Variant; __pyx_t_4 = NULL;
    __pyx_t_6 = 0;
    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1);
      if (likely(__pyx_t_4)) {
        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
        __Pyx_INCREF(__pyx_t_4);
        __Pyx_INCREF(function);
        __Pyx_DECREF_SET(__pyx_t_1, function);
        __pyx_t_6 = 1;
      }
    }
    #if CYTHON_FAST_PYCALL
    if (PyFunction_Check(__pyx_t_1)) {
      PyObject *__pyx_temp[4] = {__pyx_t_4, __pyx_n_u_s, __pyx_v_self->error_name, Py_False};
      __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 3+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 275, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_GOTREF(__pyx_t_2);
    } else
    #endif
    #if CYTHON_FAST_PYCCALL
    if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) {
      PyObject *__pyx_temp[4] = {__pyx_t_4, __pyx_n_u_s, __pyx_v_self->error_name, Py_False};
      __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 3+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 275, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_GOTREF(__pyx_t_2);
    } else
    #endif
    {
      __pyx_t_3 = PyTuple_New(3+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 275, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      if (__pyx_t_4) {
        __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); __pyx_t_4 = NULL;
      }
      __Pyx_INCREF(__pyx_n_u_s);
      __Pyx_GIVEREF(__pyx_n_u_s);
      PyTuple_SET_ITEM(__pyx_t_3, 0+__pyx_t_6, __pyx_n_u_s);
      __Pyx_INCREF(__pyx_v_self->error_name);
      __Pyx_GIVEREF(__pyx_v_self->error_name);
      PyTuple_SET_ITEM(__pyx_t_3, 1+__pyx_t_6, __pyx_v_self->error_name);
      __Pyx_INCREF(Py_False);
      __Pyx_GIVEREF(Py_False);
      PyTuple_SET_ITEM(__pyx_t_3, 2+__pyx_t_6, Py_False);
      __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 275, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    }
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_1 = PyList_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 275, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_INCREF(__pyx_v_9dbus_fast_7message_HEADER_ERROR_NAME);
    __Pyx_GIVEREF(__pyx_v_9dbus_fast_7message_HEADER_ERROR_NAME);
    PyList_SET_ITEM(__pyx_t_1, 0, __pyx_v_9dbus_fast_7message_HEADER_ERROR_NAME);
    __Pyx_GIVEREF(__pyx_t_2);
    PyList_SET_ITEM(__pyx_t_1, 1, __pyx_t_2);
    __pyx_t_2 = 0;
    __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_fields, __pyx_t_1); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(0, 275, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+276:         if self.reply_serial:

  __pyx_t_7 = (__pyx_v_self->reply_serial != 0);
  if (__pyx_t_7) {
/* … */
  }

+277:             fields.append([HEADER_REPLY_SERIAL, Variant("u", self.reply_serial, False)])

    __pyx_t_2 = __Pyx_PyInt_From_unsigned_int(__pyx_v_self->reply_serial); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 277, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_INCREF(__pyx_v_9dbus_fast_7message_Variant);
    __pyx_t_3 = __pyx_v_9dbus_fast_7message_Variant; __pyx_t_4 = NULL;
    __pyx_t_6 = 0;
    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
      if (likely(__pyx_t_4)) {
        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
        __Pyx_INCREF(__pyx_t_4);
        __Pyx_INCREF(function);
        __Pyx_DECREF_SET(__pyx_t_3, function);
        __pyx_t_6 = 1;
      }
    }
    #if CYTHON_FAST_PYCALL
    if (PyFunction_Check(__pyx_t_3)) {
      PyObject *__pyx_temp[4] = {__pyx_t_4, __pyx_n_u_u, __pyx_t_2, Py_False};
      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 3+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 277, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    } else
    #endif
    #if CYTHON_FAST_PYCCALL
    if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
      PyObject *__pyx_temp[4] = {__pyx_t_4, __pyx_n_u_u, __pyx_t_2, Py_False};
      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 3+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 277, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    } else
    #endif
    {
      __pyx_t_5 = PyTuple_New(3+__pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 277, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      if (__pyx_t_4) {
        __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL;
      }
      __Pyx_INCREF(__pyx_n_u_u);
      __Pyx_GIVEREF(__pyx_n_u_u);
      PyTuple_SET_ITEM(__pyx_t_5, 0+__pyx_t_6, __pyx_n_u_u);
      __Pyx_GIVEREF(__pyx_t_2);
      PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_6, __pyx_t_2);
      __Pyx_INCREF(Py_False);
      __Pyx_GIVEREF(Py_False);
      PyTuple_SET_ITEM(__pyx_t_5, 2+__pyx_t_6, Py_False);
      __pyx_t_2 = 0;
      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 277, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    }
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = PyList_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 277, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_INCREF(__pyx_v_9dbus_fast_7message_HEADER_REPLY_SERIAL);
    __Pyx_GIVEREF(__pyx_v_9dbus_fast_7message_HEADER_REPLY_SERIAL);
    PyList_SET_ITEM(__pyx_t_3, 0, __pyx_v_9dbus_fast_7message_HEADER_REPLY_SERIAL);
    __Pyx_GIVEREF(__pyx_t_1);
    PyList_SET_ITEM(__pyx_t_3, 1, __pyx_t_1);
    __pyx_t_1 = 0;
    __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_fields, __pyx_t_3); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(0, 277, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+278:         if self.destination:

  __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_self->destination); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 278, __pyx_L1_error)
  if (__pyx_t_7) {
/* … */
  }

+279:             fields.append([HEADER_DESTINATION, Variant("s", self.destination, False)])

    __Pyx_INCREF(__pyx_v_9dbus_fast_7message_Variant);
    __pyx_t_1 = __pyx_v_9dbus_fast_7message_Variant; __pyx_t_5 = NULL;
    __pyx_t_6 = 0;
    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
      __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1);
      if (likely(__pyx_t_5)) {
        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
        __Pyx_INCREF(__pyx_t_5);
        __Pyx_INCREF(function);
        __Pyx_DECREF_SET(__pyx_t_1, function);
        __pyx_t_6 = 1;
      }
    }
    #if CYTHON_FAST_PYCALL
    if (PyFunction_Check(__pyx_t_1)) {
      PyObject *__pyx_temp[4] = {__pyx_t_5, __pyx_n_u_s, __pyx_v_self->destination, Py_False};
      __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 3+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 279, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_GOTREF(__pyx_t_3);
    } else
    #endif
    #if CYTHON_FAST_PYCCALL
    if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) {
      PyObject *__pyx_temp[4] = {__pyx_t_5, __pyx_n_u_s, __pyx_v_self->destination, Py_False};
      __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 3+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 279, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_GOTREF(__pyx_t_3);
    } else
    #endif
    {
      __pyx_t_2 = PyTuple_New(3+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 279, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      if (__pyx_t_5) {
        __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_5); __pyx_t_5 = NULL;
      }
      __Pyx_INCREF(__pyx_n_u_s);
      __Pyx_GIVEREF(__pyx_n_u_s);
      PyTuple_SET_ITEM(__pyx_t_2, 0+__pyx_t_6, __pyx_n_u_s);
      __Pyx_INCREF(__pyx_v_self->destination);
      __Pyx_GIVEREF(__pyx_v_self->destination);
      PyTuple_SET_ITEM(__pyx_t_2, 1+__pyx_t_6, __pyx_v_self->destination);
      __Pyx_INCREF(Py_False);
      __Pyx_GIVEREF(Py_False);
      PyTuple_SET_ITEM(__pyx_t_2, 2+__pyx_t_6, Py_False);
      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 279, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    }
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_1 = PyList_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 279, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_INCREF(__pyx_v_9dbus_fast_7message_HEADER_DESTINATION);
    __Pyx_GIVEREF(__pyx_v_9dbus_fast_7message_HEADER_DESTINATION);
    PyList_SET_ITEM(__pyx_t_1, 0, __pyx_v_9dbus_fast_7message_HEADER_DESTINATION);
    __Pyx_GIVEREF(__pyx_t_3);
    PyList_SET_ITEM(__pyx_t_1, 1, __pyx_t_3);
    __pyx_t_3 = 0;
    __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_fields, __pyx_t_1); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(0, 279, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+280:         if self.signature:

  __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_self->signature); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 280, __pyx_L1_error)
  if (__pyx_t_7) {
/* … */
  }

+281:             fields.append([HEADER_SIGNATURE, Variant("g", self.signature, False)])

    __Pyx_INCREF(__pyx_v_9dbus_fast_7message_Variant);
    __pyx_t_3 = __pyx_v_9dbus_fast_7message_Variant; __pyx_t_2 = NULL;
    __pyx_t_6 = 0;
    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
      __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
      if (likely(__pyx_t_2)) {
        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
        __Pyx_INCREF(__pyx_t_2);
        __Pyx_INCREF(function);
        __Pyx_DECREF_SET(__pyx_t_3, function);
        __pyx_t_6 = 1;
      }
    }
    #if CYTHON_FAST_PYCALL
    if (PyFunction_Check(__pyx_t_3)) {
      PyObject *__pyx_temp[4] = {__pyx_t_2, __pyx_n_u_g, __pyx_v_self->signature, Py_False};
      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 3+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 281, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_GOTREF(__pyx_t_1);
    } else
    #endif
    #if CYTHON_FAST_PYCCALL
    if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
      PyObject *__pyx_temp[4] = {__pyx_t_2, __pyx_n_u_g, __pyx_v_self->signature, Py_False};
      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 3+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 281, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_GOTREF(__pyx_t_1);
    } else
    #endif
    {
      __pyx_t_5 = PyTuple_New(3+__pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 281, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      if (__pyx_t_2) {
        __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2); __pyx_t_2 = NULL;
      }
      __Pyx_INCREF(__pyx_n_u_g);
      __Pyx_GIVEREF(__pyx_n_u_g);
      PyTuple_SET_ITEM(__pyx_t_5, 0+__pyx_t_6, __pyx_n_u_g);
      __Pyx_INCREF(__pyx_v_self->signature);
      __Pyx_GIVEREF(__pyx_v_self->signature);
      PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_6, __pyx_v_self->signature);
      __Pyx_INCREF(Py_False);
      __Pyx_GIVEREF(Py_False);
      PyTuple_SET_ITEM(__pyx_t_5, 2+__pyx_t_6, Py_False);
      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 281, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    }
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = PyList_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 281, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_INCREF(__pyx_v_9dbus_fast_7message_HEADER_SIGNATURE);
    __Pyx_GIVEREF(__pyx_v_9dbus_fast_7message_HEADER_SIGNATURE);
    PyList_SET_ITEM(__pyx_t_3, 0, __pyx_v_9dbus_fast_7message_HEADER_SIGNATURE);
    __Pyx_GIVEREF(__pyx_t_1);
    PyList_SET_ITEM(__pyx_t_3, 1, __pyx_t_1);
    __pyx_t_1 = 0;
    __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_fields, __pyx_t_3); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(0, 281, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

+282:         if self.unix_fds and negotiate_unix_fd:

  __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_self->unix_fds); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 282, __pyx_L1_error)
  if (__pyx_t_9) {
  } else {
    __pyx_t_7 = __pyx_t_9;
    goto __pyx_L11_bool_binop_done;
  }
  __pyx_t_9 = (__pyx_v_negotiate_unix_fd != 0);
  __pyx_t_7 = __pyx_t_9;
  __pyx_L11_bool_binop_done:;
  if (__pyx_t_7) {
/* … */
  }

+283:             fields.append([HEADER_UNIX_FDS, Variant("u", len(self.unix_fds), False)])

    __pyx_t_1 = __pyx_v_self->unix_fds;
    __Pyx_INCREF(__pyx_t_1);
    __pyx_t_10 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_10 == ((Py_ssize_t)-1))) __PYX_ERR(0, 283, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_1 = PyInt_FromSsize_t(__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 283, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_INCREF(__pyx_v_9dbus_fast_7message_Variant);
    __pyx_t_5 = __pyx_v_9dbus_fast_7message_Variant; __pyx_t_2 = NULL;
    __pyx_t_6 = 0;
    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) {
      __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_5);
      if (likely(__pyx_t_2)) {
        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
        __Pyx_INCREF(__pyx_t_2);
        __Pyx_INCREF(function);
        __Pyx_DECREF_SET(__pyx_t_5, function);
        __pyx_t_6 = 1;
      }
    }
    #if CYTHON_FAST_PYCALL
    if (PyFunction_Check(__pyx_t_5)) {
      PyObject *__pyx_temp[4] = {__pyx_t_2, __pyx_n_u_u, __pyx_t_1, Py_False};
      __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_6, 3+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 283, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    } else
    #endif
    #if CYTHON_FAST_PYCCALL
    if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
      PyObject *__pyx_temp[4] = {__pyx_t_2, __pyx_n_u_u, __pyx_t_1, Py_False};
      __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_6, 3+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 283, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    } else
    #endif
    {
      __pyx_t_4 = PyTuple_New(3+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 283, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      if (__pyx_t_2) {
        __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); __pyx_t_2 = NULL;
      }
      __Pyx_INCREF(__pyx_n_u_u);
      __Pyx_GIVEREF(__pyx_n_u_u);
      PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_6, __pyx_n_u_u);
      __Pyx_GIVEREF(__pyx_t_1);
      PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_6, __pyx_t_1);
      __Pyx_INCREF(Py_False);
      __Pyx_GIVEREF(Py_False);
      PyTuple_SET_ITEM(__pyx_t_4, 2+__pyx_t_6, Py_False);
      __pyx_t_1 = 0;
      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 283, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    }
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_5 = PyList_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 283, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_INCREF(__pyx_v_9dbus_fast_7message_HEADER_UNIX_FDS);
    __Pyx_GIVEREF(__pyx_v_9dbus_fast_7message_HEADER_UNIX_FDS);
    PyList_SET_ITEM(__pyx_t_5, 0, __pyx_v_9dbus_fast_7message_HEADER_UNIX_FDS);
    __Pyx_GIVEREF(__pyx_t_3);
    PyList_SET_ITEM(__pyx_t_5, 1, __pyx_t_3);
    __pyx_t_3 = 0;
    __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_fields, __pyx_t_5); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(0, 283, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

 284:

+285:         header_body = [

  __pyx_t_2 = PyList_New(7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 285, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_INCREF(__pyx_v_9dbus_fast_7message_LITTLE_ENDIAN);
  __Pyx_GIVEREF(__pyx_v_9dbus_fast_7message_LITTLE_ENDIAN);
  PyList_SET_ITEM(__pyx_t_2, 0, __pyx_v_9dbus_fast_7message_LITTLE_ENDIAN);
  __Pyx_GIVEREF(__pyx_t_5);
  PyList_SET_ITEM(__pyx_t_2, 1, __pyx_t_5);
  __Pyx_GIVEREF(__pyx_t_3);
  PyList_SET_ITEM(__pyx_t_2, 2, __pyx_t_3);
  __Pyx_INCREF(__pyx_v_9dbus_fast_7message_PROTOCOL_VERSION);
  __Pyx_GIVEREF(__pyx_v_9dbus_fast_7message_PROTOCOL_VERSION);
  PyList_SET_ITEM(__pyx_t_2, 3, __pyx_v_9dbus_fast_7message_PROTOCOL_VERSION);
  __Pyx_GIVEREF(__pyx_t_4);
  PyList_SET_ITEM(__pyx_t_2, 4, __pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_1);
  PyList_SET_ITEM(__pyx_t_2, 5, __pyx_t_1);
  __Pyx_INCREF(__pyx_v_fields);
  __Pyx_GIVEREF(__pyx_v_fields);
  PyList_SET_ITEM(__pyx_t_2, 6, __pyx_v_fields);
  __pyx_t_5 = 0;
  __pyx_t_3 = 0;
  __pyx_t_4 = 0;
  __pyx_t_1 = 0;
  __pyx_v_header_body = ((PyObject*)__pyx_t_2);
  __pyx_t_2 = 0;

 286:             LITTLE_ENDIAN,

+287:             self.message_type.value,

  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->message_type, __pyx_n_s_value); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 287, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);

+288:             self.flags.value,

  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->flags, __pyx_n_s_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 288, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);

 289:             PROTOCOL_VERSION,

+290:             len(body_block.buffer),

  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_body_block, __pyx_n_s_buffer); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 290, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_10 = PyObject_Length(__pyx_t_4); if (unlikely(__pyx_t_10 == ((Py_ssize_t)-1))) __PYX_ERR(0, 290, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = PyInt_FromSsize_t(__pyx_t_10); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 290, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);

+291:             self.serial,

  __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_v_self->serial); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 291, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

 292:             fields,

 293:         ]

+294:         header_block = Marshaller("yyyyuua(yv)", header_body)

  __Pyx_INCREF(__pyx_v_9dbus_fast_7message_Marshaller);
  __pyx_t_1 = __pyx_v_9dbus_fast_7message_Marshaller; __pyx_t_4 = NULL;
  __pyx_t_6 = 0;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1);
    if (likely(__pyx_t_4)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_1, function);
      __pyx_t_6 = 1;
    }
  }
  #if CYTHON_FAST_PYCALL
  if (PyFunction_Check(__pyx_t_1)) {
    PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_kp_u_yyyyuua_yv, __pyx_v_header_body};
    __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 294, __pyx_L1_error)
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_GOTREF(__pyx_t_2);
  } else
  #endif
  #if CYTHON_FAST_PYCCALL
  if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) {
    PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_kp_u_yyyyuua_yv, __pyx_v_header_body};
    __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 294, __pyx_L1_error)
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_GOTREF(__pyx_t_2);
  } else
  #endif
  {
    __pyx_t_3 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 294, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    if (__pyx_t_4) {
      __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); __pyx_t_4 = NULL;
    }
    __Pyx_INCREF(__pyx_kp_u_yyyyuua_yv);
    __Pyx_GIVEREF(__pyx_kp_u_yyyyuua_yv);
    PyTuple_SET_ITEM(__pyx_t_3, 0+__pyx_t_6, __pyx_kp_u_yyyyuua_yv);
    __Pyx_INCREF(__pyx_v_header_body);
    __Pyx_GIVEREF(__pyx_v_header_body);
    PyTuple_SET_ITEM(__pyx_t_3, 1+__pyx_t_6, __pyx_v_header_body);
    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 294, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_header_block = __pyx_t_2;
  __pyx_t_2 = 0;

+295:         header_block.marshall()

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_header_block, __pyx_n_s_marshall_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 295, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_1, function);
    }
  }
  __pyx_t_2 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 295, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+296:         header_block.align(8)

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_header_block, __pyx_n_s_align); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 296, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_1, function);
    }
  }
  __pyx_t_2 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_3, __pyx_int_8) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_int_8);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 296, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+297:         return header_block.buffer + body_block.buffer

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_header_block, __pyx_n_s_buffer); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 297, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_body_block, __pyx_n_s_buffer); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 297, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = PyNumber_Add(__pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 297, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;