// This file is generated by Simplicity Studio.  Please do not edit manually.
//
//
#include "debug-util.h"

//yjq add for test
#define EMBER_AF_PRINT_REPORTING 0x0008
#define EMBER_AF_PRINT_IAS_ZONE_CLUSTER 0x0008
#define EMBER_AF_PRINT_POLL_CONTROL_CLUSTER 0x0008



// Enclosing macro to prevent multiple inclusion
#ifndef SILABS_EMBER_AF_DEBUG_PRINTING
#define SILABS_EMBER_AF_DEBUG_PRINTING

#define DEBUG_INIT(appName) DEBUG_LOG_OPENLOG(appName)

// Printing macros for cluster: Basic
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BASIC_CLUSTER)
#define emberAfBasicClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_BASIC_CLUSTER, __VA_ARGS__)
#define emberAfBasicClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_BASIC_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfBasicClusterFlush()
#define emberAfBasicClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_BASIC_CLUSTER) ) { x; }
#define emberAfBasicClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_BASIC_CLUSTER, (buffer), (len), (withSpace))
#define emberAfBasicClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_BASIC_CLUSTER, (buffer))
#else
#define emberAfBasicClusterPrint(...)
#define emberAfBasicClusterPrintln(...)
#define emberAfBasicClusterFlush()
#define emberAfBasicClusterDebugExec(x)
#define emberAfBasicClusterPrintBuffer(buffer, len, withSpace)
#define emberAfBasicClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BASIC_CLUSTER)


// Printing macros for cluster: Power Configuration
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_POWER_CONFIG_CLUSTER)
#define emberAfPowerConfigClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_POWER_CONFIG_CLUSTER, __VA_ARGS__)
#define emberAfPowerConfigClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_POWER_CONFIG_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfPowerConfigClusterFlush()
#define emberAfPowerConfigClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_POWER_CONFIG_CLUSTER) ) { x; }
#define emberAfPowerConfigClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_POWER_CONFIG_CLUSTER, (buffer), (len), (withSpace))
#define emberAfPowerConfigClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_POWER_CONFIG_CLUSTER, (buffer))
#else
#define emberAfPowerConfigClusterPrint(...)
#define emberAfPowerConfigClusterPrintln(...)
#define emberAfPowerConfigClusterFlush()
#define emberAfPowerConfigClusterDebugExec(x)
#define emberAfPowerConfigClusterPrintBuffer(buffer, len, withSpace)
#define emberAfPowerConfigClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_POWER_CONFIG_CLUSTER)


// Printing macros for cluster: Device Temperature Configuration
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEVICE_TEMP_CLUSTER)
#define emberAfDeviceTempClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_DEVICE_TEMP_CLUSTER, __VA_ARGS__)
#define emberAfDeviceTempClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DEVICE_TEMP_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfDeviceTempClusterFlush()
#define emberAfDeviceTempClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_DEVICE_TEMP_CLUSTER) ) { x; }
#define emberAfDeviceTempClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_DEVICE_TEMP_CLUSTER, (buffer), (len), (withSpace))
#define emberAfDeviceTempClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_DEVICE_TEMP_CLUSTER, (buffer))
#else
#define emberAfDeviceTempClusterPrint(...)
#define emberAfDeviceTempClusterPrintln(...)
#define emberAfDeviceTempClusterFlush()
#define emberAfDeviceTempClusterDebugExec(x)
#define emberAfDeviceTempClusterPrintBuffer(buffer, len, withSpace)
#define emberAfDeviceTempClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEVICE_TEMP_CLUSTER)


// Printing macros for cluster: Identify
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_IDENTIFY_CLUSTER)
#define emberAfIdentifyClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_IDENTIFY_CLUSTER, __VA_ARGS__)
#define emberAfIdentifyClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_IDENTIFY_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfIdentifyClusterFlush()
#define emberAfIdentifyClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_IDENTIFY_CLUSTER) ) { x; }
#define emberAfIdentifyClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_IDENTIFY_CLUSTER, (buffer), (len), (withSpace))
#define emberAfIdentifyClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_IDENTIFY_CLUSTER, (buffer))
#else
#define emberAfIdentifyClusterPrint(...)
#define emberAfIdentifyClusterPrintln(...)
#define emberAfIdentifyClusterFlush()
#define emberAfIdentifyClusterDebugExec(x)
#define emberAfIdentifyClusterPrintBuffer(buffer, len, withSpace)
#define emberAfIdentifyClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_IDENTIFY_CLUSTER)


// Printing macros for cluster: Groups
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_GROUPS_CLUSTER)
#define emberAfGroupsClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_GROUPS_CLUSTER, __VA_ARGS__)
#define emberAfGroupsClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_GROUPS_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfGroupsClusterFlush()
#define emberAfGroupsClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_GROUPS_CLUSTER) ) { x; }
#define emberAfGroupsClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_GROUPS_CLUSTER, (buffer), (len), (withSpace))
#define emberAfGroupsClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_GROUPS_CLUSTER, (buffer))
#else
#define emberAfGroupsClusterPrint(...)
#define emberAfGroupsClusterPrintln(...)
#define emberAfGroupsClusterFlush()
#define emberAfGroupsClusterDebugExec(x)
#define emberAfGroupsClusterPrintBuffer(buffer, len, withSpace)
#define emberAfGroupsClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_GROUPS_CLUSTER)


// Printing macros for cluster: Scenes
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SCENES_CLUSTER)
#define emberAfScenesClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_SCENES_CLUSTER, __VA_ARGS__)
#define emberAfScenesClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SCENES_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfScenesClusterFlush()
#define emberAfScenesClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_SCENES_CLUSTER) ) { x; }
#define emberAfScenesClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_SCENES_CLUSTER, (buffer), (len), (withSpace))
#define emberAfScenesClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SCENES_CLUSTER, (buffer))
#else
#define emberAfScenesClusterPrint(...)
#define emberAfScenesClusterPrintln(...)
#define emberAfScenesClusterFlush()
#define emberAfScenesClusterDebugExec(x)
#define emberAfScenesClusterPrintBuffer(buffer, len, withSpace)
#define emberAfScenesClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SCENES_CLUSTER)


// Printing macros for cluster: On/off
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ON_OFF_CLUSTER)
#define emberAfOnOffClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ON_OFF_CLUSTER, __VA_ARGS__)
#define emberAfOnOffClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ON_OFF_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfOnOffClusterFlush()
#define emberAfOnOffClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_ON_OFF_CLUSTER) ) { x; }
#define emberAfOnOffClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_ON_OFF_CLUSTER, (buffer), (len), (withSpace))
#define emberAfOnOffClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ON_OFF_CLUSTER, (buffer))
#else
#define emberAfOnOffClusterPrint(...)
#define emberAfOnOffClusterPrintln(...)
#define emberAfOnOffClusterFlush()
#define emberAfOnOffClusterDebugExec(x)
#define emberAfOnOffClusterPrintBuffer(buffer, len, withSpace)
#define emberAfOnOffClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ON_OFF_CLUSTER)


// Printing macros for cluster: On/off Switch Configuration
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ON_OFF_SWITCH_CONFIG_CLUSTER)
#define emberAfOnOffSwitchConfigClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ON_OFF_SWITCH_CONFIG_CLUSTER, __VA_ARGS__)
#define emberAfOnOffSwitchConfigClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ON_OFF_SWITCH_CONFIG_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfOnOffSwitchConfigClusterFlush()
#define emberAfOnOffSwitchConfigClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_ON_OFF_SWITCH_CONFIG_CLUSTER) ) { x; }
#define emberAfOnOffSwitchConfigClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_ON_OFF_SWITCH_CONFIG_CLUSTER, (buffer), (len), (withSpace))
#define emberAfOnOffSwitchConfigClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ON_OFF_SWITCH_CONFIG_CLUSTER, (buffer))
#else
#define emberAfOnOffSwitchConfigClusterPrint(...)
#define emberAfOnOffSwitchConfigClusterPrintln(...)
#define emberAfOnOffSwitchConfigClusterFlush()
#define emberAfOnOffSwitchConfigClusterDebugExec(x)
#define emberAfOnOffSwitchConfigClusterPrintBuffer(buffer, len, withSpace)
#define emberAfOnOffSwitchConfigClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ON_OFF_SWITCH_CONFIG_CLUSTER)


// Printing macros for cluster: Level Control
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_LEVEL_CONTROL_CLUSTER)
#define emberAfLevelControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_LEVEL_CONTROL_CLUSTER, __VA_ARGS__)
#define emberAfLevelControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_LEVEL_CONTROL_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfLevelControlClusterFlush()
#define emberAfLevelControlClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_LEVEL_CONTROL_CLUSTER) ) { x; }
#define emberAfLevelControlClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_LEVEL_CONTROL_CLUSTER, (buffer), (len), (withSpace))
#define emberAfLevelControlClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_LEVEL_CONTROL_CLUSTER, (buffer))
#else
#define emberAfLevelControlClusterPrint(...)
#define emberAfLevelControlClusterPrintln(...)
#define emberAfLevelControlClusterFlush()
#define emberAfLevelControlClusterDebugExec(x)
#define emberAfLevelControlClusterPrintBuffer(buffer, len, withSpace)
#define emberAfLevelControlClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_LEVEL_CONTROL_CLUSTER)


// Printing macros for cluster: Alarms
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ALARM_CLUSTER)
#define emberAfAlarmClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ALARM_CLUSTER, __VA_ARGS__)
#define emberAfAlarmClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ALARM_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfAlarmClusterFlush()
#define emberAfAlarmClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_ALARM_CLUSTER) ) { x; }
#define emberAfAlarmClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_ALARM_CLUSTER, (buffer), (len), (withSpace))
#define emberAfAlarmClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ALARM_CLUSTER, (buffer))
#else
#define emberAfAlarmClusterPrint(...)
#define emberAfAlarmClusterPrintln(...)
#define emberAfAlarmClusterFlush()
#define emberAfAlarmClusterDebugExec(x)
#define emberAfAlarmClusterPrintBuffer(buffer, len, withSpace)
#define emberAfAlarmClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ALARM_CLUSTER)


// Printing macros for cluster: Time
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TIME_CLUSTER)
#define emberAfTimeClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_TIME_CLUSTER, __VA_ARGS__)
#define emberAfTimeClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_TIME_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfTimeClusterFlush()
#define emberAfTimeClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_TIME_CLUSTER) ) { x; }
#define emberAfTimeClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_TIME_CLUSTER, (buffer), (len), (withSpace))
#define emberAfTimeClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_TIME_CLUSTER, (buffer))
#else
#define emberAfTimeClusterPrint(...)
#define emberAfTimeClusterPrintln(...)
#define emberAfTimeClusterFlush()
#define emberAfTimeClusterDebugExec(x)
#define emberAfTimeClusterPrintBuffer(buffer, len, withSpace)
#define emberAfTimeClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TIME_CLUSTER)


// Printing macros for cluster: RSSI Location
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_RSSI_LOCATION_CLUSTER)
#define emberAfRssiLocationClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_RSSI_LOCATION_CLUSTER, __VA_ARGS__)
#define emberAfRssiLocationClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_RSSI_LOCATION_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfRssiLocationClusterFlush()
#define emberAfRssiLocationClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_RSSI_LOCATION_CLUSTER) ) { x; }
#define emberAfRssiLocationClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_RSSI_LOCATION_CLUSTER, (buffer), (len), (withSpace))
#define emberAfRssiLocationClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_RSSI_LOCATION_CLUSTER, (buffer))
#else
#define emberAfRssiLocationClusterPrint(...)
#define emberAfRssiLocationClusterPrintln(...)
#define emberAfRssiLocationClusterFlush()
#define emberAfRssiLocationClusterDebugExec(x)
#define emberAfRssiLocationClusterPrintBuffer(buffer, len, withSpace)
#define emberAfRssiLocationClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_RSSI_LOCATION_CLUSTER)


// Printing macros for cluster: Binary Input (Basic)
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BINARY_INPUT_BASIC_CLUSTER)
#define emberAfBinaryInputBasicClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_BINARY_INPUT_BASIC_CLUSTER, __VA_ARGS__)
#define emberAfBinaryInputBasicClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_BINARY_INPUT_BASIC_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfBinaryInputBasicClusterFlush()
#define emberAfBinaryInputBasicClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_BINARY_INPUT_BASIC_CLUSTER) ) { x; }
#define emberAfBinaryInputBasicClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_BINARY_INPUT_BASIC_CLUSTER, (buffer), (len), (withSpace))
#define emberAfBinaryInputBasicClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_BINARY_INPUT_BASIC_CLUSTER, (buffer))
#else
#define emberAfBinaryInputBasicClusterPrint(...)
#define emberAfBinaryInputBasicClusterPrintln(...)
#define emberAfBinaryInputBasicClusterFlush()
#define emberAfBinaryInputBasicClusterDebugExec(x)
#define emberAfBinaryInputBasicClusterPrintBuffer(buffer, len, withSpace)
#define emberAfBinaryInputBasicClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BINARY_INPUT_BASIC_CLUSTER)


// Printing macros for cluster: Commissioning
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_COMMISSIONING_CLUSTER)
#define emberAfCommissioningClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_COMMISSIONING_CLUSTER, __VA_ARGS__)
#define emberAfCommissioningClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_COMMISSIONING_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfCommissioningClusterFlush()
#define emberAfCommissioningClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_COMMISSIONING_CLUSTER) ) { x; }
#define emberAfCommissioningClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_COMMISSIONING_CLUSTER, (buffer), (len), (withSpace))
#define emberAfCommissioningClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_COMMISSIONING_CLUSTER, (buffer))
#else
#define emberAfCommissioningClusterPrint(...)
#define emberAfCommissioningClusterPrintln(...)
#define emberAfCommissioningClusterFlush()
#define emberAfCommissioningClusterDebugExec(x)
#define emberAfCommissioningClusterPrintBuffer(buffer, len, withSpace)
#define emberAfCommissioningClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_COMMISSIONING_CLUSTER)


// Printing macros for cluster: Partition
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PARTITION_CLUSTER)
#define emberAfPartitionClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_PARTITION_CLUSTER, __VA_ARGS__)
#define emberAfPartitionClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_PARTITION_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfPartitionClusterFlush()
#define emberAfPartitionClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_PARTITION_CLUSTER) ) { x; }
#define emberAfPartitionClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_PARTITION_CLUSTER, (buffer), (len), (withSpace))
#define emberAfPartitionClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_PARTITION_CLUSTER, (buffer))
#else
#define emberAfPartitionClusterPrint(...)
#define emberAfPartitionClusterPrintln(...)
#define emberAfPartitionClusterFlush()
#define emberAfPartitionClusterDebugExec(x)
#define emberAfPartitionClusterPrintBuffer(buffer, len, withSpace)
#define emberAfPartitionClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PARTITION_CLUSTER)


// Printing macros for cluster: Over the Air Bootloading
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OTA_BOOTLOAD_CLUSTER)
#define emberAfOtaBootloadClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_OTA_BOOTLOAD_CLUSTER, __VA_ARGS__)
#define emberAfOtaBootloadClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_OTA_BOOTLOAD_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfOtaBootloadClusterFlush()
#define emberAfOtaBootloadClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_OTA_BOOTLOAD_CLUSTER) ) { x; }
#define emberAfOtaBootloadClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_OTA_BOOTLOAD_CLUSTER, (buffer), (len), (withSpace))
#define emberAfOtaBootloadClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_OTA_BOOTLOAD_CLUSTER, (buffer))
#else
#define emberAfOtaBootloadClusterPrint(...)
#define emberAfOtaBootloadClusterPrintln(...)
#define emberAfOtaBootloadClusterFlush()
#define emberAfOtaBootloadClusterDebugExec(x)
#define emberAfOtaBootloadClusterPrintBuffer(buffer, len, withSpace)
#define emberAfOtaBootloadClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OTA_BOOTLOAD_CLUSTER)


// Printing macros for cluster: Power Profile
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_POWER_PROFILE_CLUSTER)
#define emberAfPowerProfileClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_POWER_PROFILE_CLUSTER, __VA_ARGS__)
#define emberAfPowerProfileClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_POWER_PROFILE_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfPowerProfileClusterFlush()
#define emberAfPowerProfileClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_POWER_PROFILE_CLUSTER) ) { x; }
#define emberAfPowerProfileClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_POWER_PROFILE_CLUSTER, (buffer), (len), (withSpace))
#define emberAfPowerProfileClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_POWER_PROFILE_CLUSTER, (buffer))
#else
#define emberAfPowerProfileClusterPrint(...)
#define emberAfPowerProfileClusterPrintln(...)
#define emberAfPowerProfileClusterFlush()
#define emberAfPowerProfileClusterDebugExec(x)
#define emberAfPowerProfileClusterPrintBuffer(buffer, len, withSpace)
#define emberAfPowerProfileClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_POWER_PROFILE_CLUSTER)


// Printing macros for cluster: Appliance Control
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APPLIANCE_CONTROL_CLUSTER)
#define emberAfApplianceControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_APPLIANCE_CONTROL_CLUSTER, __VA_ARGS__)
#define emberAfApplianceControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_APPLIANCE_CONTROL_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfApplianceControlClusterFlush()
#define emberAfApplianceControlClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_APPLIANCE_CONTROL_CLUSTER) ) { x; }
#define emberAfApplianceControlClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_APPLIANCE_CONTROL_CLUSTER, (buffer), (len), (withSpace))
#define emberAfApplianceControlClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_APPLIANCE_CONTROL_CLUSTER, (buffer))
#else
#define emberAfApplianceControlClusterPrint(...)
#define emberAfApplianceControlClusterPrintln(...)
#define emberAfApplianceControlClusterFlush()
#define emberAfApplianceControlClusterDebugExec(x)
#define emberAfApplianceControlClusterPrintBuffer(buffer, len, withSpace)
#define emberAfApplianceControlClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APPLIANCE_CONTROL_CLUSTER)


// Printing macros for cluster: Poll Control
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_POLL_CONTROL_CLUSTER)
#define emberAfPollControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_POLL_CONTROL_CLUSTER, __VA_ARGS__)
#define emberAfPollControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_POLL_CONTROL_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfPollControlClusterFlush()
#define emberAfPollControlClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_POLL_CONTROL_CLUSTER) ) { x; }
#define emberAfPollControlClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_POLL_CONTROL_CLUSTER, (buffer), (len), (withSpace))
#define emberAfPollControlClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_POLL_CONTROL_CLUSTER, (buffer))
#else
#define emberAfPollControlClusterPrint(...)
#define emberAfPollControlClusterPrintln(...)
#define emberAfPollControlClusterFlush()
#define emberAfPollControlClusterDebugExec(x)
#define emberAfPollControlClusterPrintBuffer(buffer, len, withSpace)
#define emberAfPollControlClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_POLL_CONTROL_CLUSTER)


// Printing macros for cluster: Green Power
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_GREEN_POWER_CLUSTER)
#define emberAfGreenPowerClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_GREEN_POWER_CLUSTER, __VA_ARGS__)
#define emberAfGreenPowerClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_GREEN_POWER_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfGreenPowerClusterFlush()
#define emberAfGreenPowerClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_GREEN_POWER_CLUSTER) ) { x; }
#define emberAfGreenPowerClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_GREEN_POWER_CLUSTER, (buffer), (len), (withSpace))
#define emberAfGreenPowerClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_GREEN_POWER_CLUSTER, (buffer))
#else
#define emberAfGreenPowerClusterPrint(...)
#define emberAfGreenPowerClusterPrintln(...)
#define emberAfGreenPowerClusterFlush()
#define emberAfGreenPowerClusterDebugExec(x)
#define emberAfGreenPowerClusterPrintBuffer(buffer, len, withSpace)
#define emberAfGreenPowerClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_GREEN_POWER_CLUSTER)


// Printing macros for cluster: Keep-Alive
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_KEEPALIVE_CLUSTER)
#define emberAfKeepaliveClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_KEEPALIVE_CLUSTER, __VA_ARGS__)
#define emberAfKeepaliveClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_KEEPALIVE_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfKeepaliveClusterFlush()
#define emberAfKeepaliveClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_KEEPALIVE_CLUSTER) ) { x; }
#define emberAfKeepaliveClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_KEEPALIVE_CLUSTER, (buffer), (len), (withSpace))
#define emberAfKeepaliveClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_KEEPALIVE_CLUSTER, (buffer))
#else
#define emberAfKeepaliveClusterPrint(...)
#define emberAfKeepaliveClusterPrintln(...)
#define emberAfKeepaliveClusterFlush()
#define emberAfKeepaliveClusterDebugExec(x)
#define emberAfKeepaliveClusterPrintBuffer(buffer, len, withSpace)
#define emberAfKeepaliveClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_KEEPALIVE_CLUSTER)


// Printing macros for cluster: Shade Configuration
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SHADE_CONFIG_CLUSTER)
#define emberAfShadeConfigClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_SHADE_CONFIG_CLUSTER, __VA_ARGS__)
#define emberAfShadeConfigClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SHADE_CONFIG_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfShadeConfigClusterFlush()
#define emberAfShadeConfigClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_SHADE_CONFIG_CLUSTER) ) { x; }
#define emberAfShadeConfigClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_SHADE_CONFIG_CLUSTER, (buffer), (len), (withSpace))
#define emberAfShadeConfigClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SHADE_CONFIG_CLUSTER, (buffer))
#else
#define emberAfShadeConfigClusterPrint(...)
#define emberAfShadeConfigClusterPrintln(...)
#define emberAfShadeConfigClusterFlush()
#define emberAfShadeConfigClusterDebugExec(x)
#define emberAfShadeConfigClusterPrintBuffer(buffer, len, withSpace)
#define emberAfShadeConfigClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SHADE_CONFIG_CLUSTER)


// Printing macros for cluster: Door Lock
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DOOR_LOCK_CLUSTER)
#define emberAfDoorLockClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_DOOR_LOCK_CLUSTER, __VA_ARGS__)
#define emberAfDoorLockClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DOOR_LOCK_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfDoorLockClusterFlush()
#define emberAfDoorLockClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_DOOR_LOCK_CLUSTER) ) { x; }
#define emberAfDoorLockClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_DOOR_LOCK_CLUSTER, (buffer), (len), (withSpace))
#define emberAfDoorLockClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_DOOR_LOCK_CLUSTER, (buffer))
#else
#define emberAfDoorLockClusterPrint(...)
#define emberAfDoorLockClusterPrintln(...)
#define emberAfDoorLockClusterFlush()
#define emberAfDoorLockClusterDebugExec(x)
#define emberAfDoorLockClusterPrintBuffer(buffer, len, withSpace)
#define emberAfDoorLockClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DOOR_LOCK_CLUSTER)


// Printing macros for cluster: Window Covering
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_WINDOW_COVERING_CLUSTER)
#define emberAfWindowCoveringClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_WINDOW_COVERING_CLUSTER, __VA_ARGS__)
#define emberAfWindowCoveringClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_WINDOW_COVERING_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfWindowCoveringClusterFlush()
#define emberAfWindowCoveringClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_WINDOW_COVERING_CLUSTER) ) { x; }
#define emberAfWindowCoveringClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_WINDOW_COVERING_CLUSTER, (buffer), (len), (withSpace))
#define emberAfWindowCoveringClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_WINDOW_COVERING_CLUSTER, (buffer))
#else
#define emberAfWindowCoveringClusterPrint(...)
#define emberAfWindowCoveringClusterPrintln(...)
#define emberAfWindowCoveringClusterFlush()
#define emberAfWindowCoveringClusterDebugExec(x)
#define emberAfWindowCoveringClusterPrintBuffer(buffer, len, withSpace)
#define emberAfWindowCoveringClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_WINDOW_COVERING_CLUSTER)


// Printing macros for cluster: Barrier Control
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BARRIER_CONTROL_CLUSTER)
#define emberAfBarrierControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_BARRIER_CONTROL_CLUSTER, __VA_ARGS__)
#define emberAfBarrierControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_BARRIER_CONTROL_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfBarrierControlClusterFlush()
#define emberAfBarrierControlClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_BARRIER_CONTROL_CLUSTER) ) { x; }
#define emberAfBarrierControlClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_BARRIER_CONTROL_CLUSTER, (buffer), (len), (withSpace))
#define emberAfBarrierControlClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_BARRIER_CONTROL_CLUSTER, (buffer))
#else
#define emberAfBarrierControlClusterPrint(...)
#define emberAfBarrierControlClusterPrintln(...)
#define emberAfBarrierControlClusterFlush()
#define emberAfBarrierControlClusterDebugExec(x)
#define emberAfBarrierControlClusterPrintBuffer(buffer, len, withSpace)
#define emberAfBarrierControlClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BARRIER_CONTROL_CLUSTER)


// Printing macros for cluster: Pump Configuration and Control
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PUMP_CONFIG_CONTROL_CLUSTER)
#define emberAfPumpConfigControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_PUMP_CONFIG_CONTROL_CLUSTER, __VA_ARGS__)
#define emberAfPumpConfigControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_PUMP_CONFIG_CONTROL_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfPumpConfigControlClusterFlush()
#define emberAfPumpConfigControlClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_PUMP_CONFIG_CONTROL_CLUSTER) ) { x; }
#define emberAfPumpConfigControlClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_PUMP_CONFIG_CONTROL_CLUSTER, (buffer), (len), (withSpace))
#define emberAfPumpConfigControlClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_PUMP_CONFIG_CONTROL_CLUSTER, (buffer))
#else
#define emberAfPumpConfigControlClusterPrint(...)
#define emberAfPumpConfigControlClusterPrintln(...)
#define emberAfPumpConfigControlClusterFlush()
#define emberAfPumpConfigControlClusterDebugExec(x)
#define emberAfPumpConfigControlClusterPrintBuffer(buffer, len, withSpace)
#define emberAfPumpConfigControlClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PUMP_CONFIG_CONTROL_CLUSTER)


// Printing macros for cluster: Thermostat
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_THERMOSTAT_CLUSTER)
#define emberAfThermostatClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_THERMOSTAT_CLUSTER, __VA_ARGS__)
#define emberAfThermostatClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_THERMOSTAT_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfThermostatClusterFlush()
#define emberAfThermostatClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_THERMOSTAT_CLUSTER) ) { x; }
#define emberAfThermostatClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_THERMOSTAT_CLUSTER, (buffer), (len), (withSpace))
#define emberAfThermostatClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_THERMOSTAT_CLUSTER, (buffer))
#else
#define emberAfThermostatClusterPrint(...)
#define emberAfThermostatClusterPrintln(...)
#define emberAfThermostatClusterFlush()
#define emberAfThermostatClusterDebugExec(x)
#define emberAfThermostatClusterPrintBuffer(buffer, len, withSpace)
#define emberAfThermostatClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_THERMOSTAT_CLUSTER)


// Printing macros for cluster: Fan Control
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_FAN_CONTROL_CLUSTER)
#define emberAfFanControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_FAN_CONTROL_CLUSTER, __VA_ARGS__)
#define emberAfFanControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_FAN_CONTROL_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfFanControlClusterFlush()
#define emberAfFanControlClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_FAN_CONTROL_CLUSTER) ) { x; }
#define emberAfFanControlClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_FAN_CONTROL_CLUSTER, (buffer), (len), (withSpace))
#define emberAfFanControlClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_FAN_CONTROL_CLUSTER, (buffer))
#else
#define emberAfFanControlClusterPrint(...)
#define emberAfFanControlClusterPrintln(...)
#define emberAfFanControlClusterFlush()
#define emberAfFanControlClusterDebugExec(x)
#define emberAfFanControlClusterPrintBuffer(buffer, len, withSpace)
#define emberAfFanControlClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_FAN_CONTROL_CLUSTER)


// Printing macros for cluster: Dehumidification Control
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEHUMID_CONTROL_CLUSTER)
#define emberAfDehumidControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_DEHUMID_CONTROL_CLUSTER, __VA_ARGS__)
#define emberAfDehumidControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DEHUMID_CONTROL_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfDehumidControlClusterFlush()
#define emberAfDehumidControlClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_DEHUMID_CONTROL_CLUSTER) ) { x; }
#define emberAfDehumidControlClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_DEHUMID_CONTROL_CLUSTER, (buffer), (len), (withSpace))
#define emberAfDehumidControlClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_DEHUMID_CONTROL_CLUSTER, (buffer))
#else
#define emberAfDehumidControlClusterPrint(...)
#define emberAfDehumidControlClusterPrintln(...)
#define emberAfDehumidControlClusterFlush()
#define emberAfDehumidControlClusterDebugExec(x)
#define emberAfDehumidControlClusterPrintBuffer(buffer, len, withSpace)
#define emberAfDehumidControlClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEHUMID_CONTROL_CLUSTER)


// Printing macros for cluster: Thermostat User Interface Configuration
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_THERMOSTAT_UI_CONFIG_CLUSTER)
#define emberAfThermostatUiConfigClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_THERMOSTAT_UI_CONFIG_CLUSTER, __VA_ARGS__)
#define emberAfThermostatUiConfigClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_THERMOSTAT_UI_CONFIG_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfThermostatUiConfigClusterFlush()
#define emberAfThermostatUiConfigClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_THERMOSTAT_UI_CONFIG_CLUSTER) ) { x; }
#define emberAfThermostatUiConfigClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_THERMOSTAT_UI_CONFIG_CLUSTER, (buffer), (len), (withSpace))
#define emberAfThermostatUiConfigClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_THERMOSTAT_UI_CONFIG_CLUSTER, (buffer))
#else
#define emberAfThermostatUiConfigClusterPrint(...)
#define emberAfThermostatUiConfigClusterPrintln(...)
#define emberAfThermostatUiConfigClusterFlush()
#define emberAfThermostatUiConfigClusterDebugExec(x)
#define emberAfThermostatUiConfigClusterPrintBuffer(buffer, len, withSpace)
#define emberAfThermostatUiConfigClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_THERMOSTAT_UI_CONFIG_CLUSTER)


// Printing macros for cluster: Color Control
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_COLOR_CONTROL_CLUSTER)
#define emberAfColorControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_COLOR_CONTROL_CLUSTER, __VA_ARGS__)
#define emberAfColorControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_COLOR_CONTROL_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfColorControlClusterFlush()
#define emberAfColorControlClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_COLOR_CONTROL_CLUSTER) ) { x; }
#define emberAfColorControlClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_COLOR_CONTROL_CLUSTER, (buffer), (len), (withSpace))
#define emberAfColorControlClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_COLOR_CONTROL_CLUSTER, (buffer))
#else
#define emberAfColorControlClusterPrint(...)
#define emberAfColorControlClusterPrintln(...)
#define emberAfColorControlClusterFlush()
#define emberAfColorControlClusterDebugExec(x)
#define emberAfColorControlClusterPrintBuffer(buffer, len, withSpace)
#define emberAfColorControlClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_COLOR_CONTROL_CLUSTER)


// Printing macros for cluster: Ballast Configuration
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BALLAST_CONFIGURATION_CLUSTER)
#define emberAfBallastConfigurationClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_BALLAST_CONFIGURATION_CLUSTER, __VA_ARGS__)
#define emberAfBallastConfigurationClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_BALLAST_CONFIGURATION_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfBallastConfigurationClusterFlush()
#define emberAfBallastConfigurationClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_BALLAST_CONFIGURATION_CLUSTER) ) { x; }
#define emberAfBallastConfigurationClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_BALLAST_CONFIGURATION_CLUSTER, (buffer), (len), (withSpace))
#define emberAfBallastConfigurationClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_BALLAST_CONFIGURATION_CLUSTER, (buffer))
#else
#define emberAfBallastConfigurationClusterPrint(...)
#define emberAfBallastConfigurationClusterPrintln(...)
#define emberAfBallastConfigurationClusterFlush()
#define emberAfBallastConfigurationClusterDebugExec(x)
#define emberAfBallastConfigurationClusterPrintBuffer(buffer, len, withSpace)
#define emberAfBallastConfigurationClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BALLAST_CONFIGURATION_CLUSTER)


// Printing macros for cluster: Illuminance Measurement
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ILLUM_MEASUREMENT_CLUSTER)
#define emberAfIllumMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ILLUM_MEASUREMENT_CLUSTER, __VA_ARGS__)
#define emberAfIllumMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ILLUM_MEASUREMENT_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfIllumMeasurementClusterFlush()
#define emberAfIllumMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_ILLUM_MEASUREMENT_CLUSTER) ) { x; }
#define emberAfIllumMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_ILLUM_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
#define emberAfIllumMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ILLUM_MEASUREMENT_CLUSTER, (buffer))
#else
#define emberAfIllumMeasurementClusterPrint(...)
#define emberAfIllumMeasurementClusterPrintln(...)
#define emberAfIllumMeasurementClusterFlush()
#define emberAfIllumMeasurementClusterDebugExec(x)
#define emberAfIllumMeasurementClusterPrintBuffer(buffer, len, withSpace)
#define emberAfIllumMeasurementClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ILLUM_MEASUREMENT_CLUSTER)


// Printing macros for cluster: Illuminance Level Sensing
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ILLUM_LEVEL_SENSING_CLUSTER)
#define emberAfIllumLevelSensingClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ILLUM_LEVEL_SENSING_CLUSTER, __VA_ARGS__)
#define emberAfIllumLevelSensingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ILLUM_LEVEL_SENSING_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfIllumLevelSensingClusterFlush()
#define emberAfIllumLevelSensingClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_ILLUM_LEVEL_SENSING_CLUSTER) ) { x; }
#define emberAfIllumLevelSensingClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_ILLUM_LEVEL_SENSING_CLUSTER, (buffer), (len), (withSpace))
#define emberAfIllumLevelSensingClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ILLUM_LEVEL_SENSING_CLUSTER, (buffer))
#else
#define emberAfIllumLevelSensingClusterPrint(...)
#define emberAfIllumLevelSensingClusterPrintln(...)
#define emberAfIllumLevelSensingClusterFlush()
#define emberAfIllumLevelSensingClusterDebugExec(x)
#define emberAfIllumLevelSensingClusterPrintBuffer(buffer, len, withSpace)
#define emberAfIllumLevelSensingClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ILLUM_LEVEL_SENSING_CLUSTER)


// Printing macros for cluster: Temperature Measurement
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TEMP_MEASUREMENT_CLUSTER)
#define emberAfTempMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_TEMP_MEASUREMENT_CLUSTER, __VA_ARGS__)
#define emberAfTempMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_TEMP_MEASUREMENT_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfTempMeasurementClusterFlush()
#define emberAfTempMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_TEMP_MEASUREMENT_CLUSTER) ) { x; }
#define emberAfTempMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_TEMP_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
#define emberAfTempMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_TEMP_MEASUREMENT_CLUSTER, (buffer))
#else
#define emberAfTempMeasurementClusterPrint(...)
#define emberAfTempMeasurementClusterPrintln(...)
#define emberAfTempMeasurementClusterFlush()
#define emberAfTempMeasurementClusterDebugExec(x)
#define emberAfTempMeasurementClusterPrintBuffer(buffer, len, withSpace)
#define emberAfTempMeasurementClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TEMP_MEASUREMENT_CLUSTER)


// Printing macros for cluster: Pressure Measurement
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PRESSURE_MEASUREMENT_CLUSTER)
#define emberAfPressureMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_PRESSURE_MEASUREMENT_CLUSTER, __VA_ARGS__)
#define emberAfPressureMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_PRESSURE_MEASUREMENT_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfPressureMeasurementClusterFlush()
#define emberAfPressureMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_PRESSURE_MEASUREMENT_CLUSTER) ) { x; }
#define emberAfPressureMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_PRESSURE_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
#define emberAfPressureMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_PRESSURE_MEASUREMENT_CLUSTER, (buffer))
#else
#define emberAfPressureMeasurementClusterPrint(...)
#define emberAfPressureMeasurementClusterPrintln(...)
#define emberAfPressureMeasurementClusterFlush()
#define emberAfPressureMeasurementClusterDebugExec(x)
#define emberAfPressureMeasurementClusterPrintBuffer(buffer, len, withSpace)
#define emberAfPressureMeasurementClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PRESSURE_MEASUREMENT_CLUSTER)


// Printing macros for cluster: Flow Measurement
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_FLOW_MEASUREMENT_CLUSTER)
#define emberAfFlowMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_FLOW_MEASUREMENT_CLUSTER, __VA_ARGS__)
#define emberAfFlowMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_FLOW_MEASUREMENT_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfFlowMeasurementClusterFlush()
#define emberAfFlowMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_FLOW_MEASUREMENT_CLUSTER) ) { x; }
#define emberAfFlowMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_FLOW_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
#define emberAfFlowMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_FLOW_MEASUREMENT_CLUSTER, (buffer))
#else
#define emberAfFlowMeasurementClusterPrint(...)
#define emberAfFlowMeasurementClusterPrintln(...)
#define emberAfFlowMeasurementClusterFlush()
#define emberAfFlowMeasurementClusterDebugExec(x)
#define emberAfFlowMeasurementClusterPrintBuffer(buffer, len, withSpace)
#define emberAfFlowMeasurementClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_FLOW_MEASUREMENT_CLUSTER)


// Printing macros for cluster: Relative Humidity Measurement
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER)
#define emberAfRelativeHumidityMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER, __VA_ARGS__)
#define emberAfRelativeHumidityMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfRelativeHumidityMeasurementClusterFlush()
#define emberAfRelativeHumidityMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER) ) { x; }
#define emberAfRelativeHumidityMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
#define emberAfRelativeHumidityMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER, (buffer))
#else
#define emberAfRelativeHumidityMeasurementClusterPrint(...)
#define emberAfRelativeHumidityMeasurementClusterPrintln(...)
#define emberAfRelativeHumidityMeasurementClusterFlush()
#define emberAfRelativeHumidityMeasurementClusterDebugExec(x)
#define emberAfRelativeHumidityMeasurementClusterPrintBuffer(buffer, len, withSpace)
#define emberAfRelativeHumidityMeasurementClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER)


// Printing macros for cluster: Occupancy Sensing
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OCCUPANCY_SENSING_CLUSTER)
#define emberAfOccupancySensingClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_OCCUPANCY_SENSING_CLUSTER, __VA_ARGS__)
#define emberAfOccupancySensingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_OCCUPANCY_SENSING_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfOccupancySensingClusterFlush()
#define emberAfOccupancySensingClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_OCCUPANCY_SENSING_CLUSTER) ) { x; }
#define emberAfOccupancySensingClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_OCCUPANCY_SENSING_CLUSTER, (buffer), (len), (withSpace))
#define emberAfOccupancySensingClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_OCCUPANCY_SENSING_CLUSTER, (buffer))
#else
#define emberAfOccupancySensingClusterPrint(...)
#define emberAfOccupancySensingClusterPrintln(...)
#define emberAfOccupancySensingClusterFlush()
#define emberAfOccupancySensingClusterDebugExec(x)
#define emberAfOccupancySensingClusterPrintBuffer(buffer, len, withSpace)
#define emberAfOccupancySensingClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OCCUPANCY_SENSING_CLUSTER)


// Printing macros for cluster: Carbon Monoxide Concentration Measurement
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER)
#define emberAfCarbonMonoxideConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
#define emberAfCarbonMonoxideConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfCarbonMonoxideConcentrationMeasurementClusterFlush()
#define emberAfCarbonMonoxideConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; }
#define emberAfCarbonMonoxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
#define emberAfCarbonMonoxideConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
#else
#define emberAfCarbonMonoxideConcentrationMeasurementClusterPrint(...)
#define emberAfCarbonMonoxideConcentrationMeasurementClusterPrintln(...)
#define emberAfCarbonMonoxideConcentrationMeasurementClusterFlush()
#define emberAfCarbonMonoxideConcentrationMeasurementClusterDebugExec(x)
#define emberAfCarbonMonoxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
#define emberAfCarbonMonoxideConcentrationMeasurementClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER)


// Printing macros for cluster: Carbon Dioxide Concentration Measurement
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER)
#define emberAfCarbonDioxideConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
#define emberAfCarbonDioxideConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfCarbonDioxideConcentrationMeasurementClusterFlush()
#define emberAfCarbonDioxideConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; }
#define emberAfCarbonDioxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
#define emberAfCarbonDioxideConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
#else
#define emberAfCarbonDioxideConcentrationMeasurementClusterPrint(...)
#define emberAfCarbonDioxideConcentrationMeasurementClusterPrintln(...)
#define emberAfCarbonDioxideConcentrationMeasurementClusterFlush()
#define emberAfCarbonDioxideConcentrationMeasurementClusterDebugExec(x)
#define emberAfCarbonDioxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
#define emberAfCarbonDioxideConcentrationMeasurementClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER)


// Printing macros for cluster: Ethylene Concentration Measurement
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER)
#define emberAfEthyleneConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
#define emberAfEthyleneConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfEthyleneConcentrationMeasurementClusterFlush()
#define emberAfEthyleneConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; }
#define emberAfEthyleneConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
#define emberAfEthyleneConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
#else
#define emberAfEthyleneConcentrationMeasurementClusterPrint(...)
#define emberAfEthyleneConcentrationMeasurementClusterPrintln(...)
#define emberAfEthyleneConcentrationMeasurementClusterFlush()
#define emberAfEthyleneConcentrationMeasurementClusterDebugExec(x)
#define emberAfEthyleneConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
#define emberAfEthyleneConcentrationMeasurementClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER)


// Printing macros for cluster: Ethylene Oxide Concentration Measurement
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER)
#define emberAfEthyleneOxideConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
#define emberAfEthyleneOxideConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfEthyleneOxideConcentrationMeasurementClusterFlush()
#define emberAfEthyleneOxideConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; }
#define emberAfEthyleneOxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
#define emberAfEthyleneOxideConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
#else
#define emberAfEthyleneOxideConcentrationMeasurementClusterPrint(...)
#define emberAfEthyleneOxideConcentrationMeasurementClusterPrintln(...)
#define emberAfEthyleneOxideConcentrationMeasurementClusterFlush()
#define emberAfEthyleneOxideConcentrationMeasurementClusterDebugExec(x)
#define emberAfEthyleneOxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
#define emberAfEthyleneOxideConcentrationMeasurementClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER)


// Printing macros for cluster: Hydrogen Concentration Measurement
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER)
#define emberAfHydrogenConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
#define emberAfHydrogenConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfHydrogenConcentrationMeasurementClusterFlush()
#define emberAfHydrogenConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; }
#define emberAfHydrogenConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
#define emberAfHydrogenConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
#else
#define emberAfHydrogenConcentrationMeasurementClusterPrint(...)
#define emberAfHydrogenConcentrationMeasurementClusterPrintln(...)
#define emberAfHydrogenConcentrationMeasurementClusterFlush()
#define emberAfHydrogenConcentrationMeasurementClusterDebugExec(x)
#define emberAfHydrogenConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
#define emberAfHydrogenConcentrationMeasurementClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER)


// Printing macros for cluster: Hydrogen Sulphide Concentration Measurement
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER)
#define emberAfHydrogenSulphideConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
#define emberAfHydrogenSulphideConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfHydrogenSulphideConcentrationMeasurementClusterFlush()
#define emberAfHydrogenSulphideConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; }
#define emberAfHydrogenSulphideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
#define emberAfHydrogenSulphideConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
#else
#define emberAfHydrogenSulphideConcentrationMeasurementClusterPrint(...)
#define emberAfHydrogenSulphideConcentrationMeasurementClusterPrintln(...)
#define emberAfHydrogenSulphideConcentrationMeasurementClusterFlush()
#define emberAfHydrogenSulphideConcentrationMeasurementClusterDebugExec(x)
#define emberAfHydrogenSulphideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
#define emberAfHydrogenSulphideConcentrationMeasurementClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER)


// Printing macros for cluster: Nitric Oxide Concentration Measurement
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER)
#define emberAfNitricOxideConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
#define emberAfNitricOxideConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfNitricOxideConcentrationMeasurementClusterFlush()
#define emberAfNitricOxideConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; }
#define emberAfNitricOxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
#define emberAfNitricOxideConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
#else
#define emberAfNitricOxideConcentrationMeasurementClusterPrint(...)
#define emberAfNitricOxideConcentrationMeasurementClusterPrintln(...)
#define emberAfNitricOxideConcentrationMeasurementClusterFlush()
#define emberAfNitricOxideConcentrationMeasurementClusterDebugExec(x)
#define emberAfNitricOxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
#define emberAfNitricOxideConcentrationMeasurementClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER)


// Printing macros for cluster: Nitrogen Dioxide Concentration Measurement
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER)
#define emberAfNitrogenDioxideConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
#define emberAfNitrogenDioxideConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfNitrogenDioxideConcentrationMeasurementClusterFlush()
#define emberAfNitrogenDioxideConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; }
#define emberAfNitrogenDioxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
#define emberAfNitrogenDioxideConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
#else
#define emberAfNitrogenDioxideConcentrationMeasurementClusterPrint(...)
#define emberAfNitrogenDioxideConcentrationMeasurementClusterPrintln(...)
#define emberAfNitrogenDioxideConcentrationMeasurementClusterFlush()
#define emberAfNitrogenDioxideConcentrationMeasurementClusterDebugExec(x)
#define emberAfNitrogenDioxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
#define emberAfNitrogenDioxideConcentrationMeasurementClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER)


// Printing macros for cluster: Oxygen Concentration Measurement
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER)
#define emberAfOxygenConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
#define emberAfOxygenConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfOxygenConcentrationMeasurementClusterFlush()
#define emberAfOxygenConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; }
#define emberAfOxygenConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
#define emberAfOxygenConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
#else
#define emberAfOxygenConcentrationMeasurementClusterPrint(...)
#define emberAfOxygenConcentrationMeasurementClusterPrintln(...)
#define emberAfOxygenConcentrationMeasurementClusterFlush()
#define emberAfOxygenConcentrationMeasurementClusterDebugExec(x)
#define emberAfOxygenConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
#define emberAfOxygenConcentrationMeasurementClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER)


// Printing macros for cluster: Ozone Concentration Measurement
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER)
#define emberAfOzoneConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
#define emberAfOzoneConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfOzoneConcentrationMeasurementClusterFlush()
#define emberAfOzoneConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; }
#define emberAfOzoneConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
#define emberAfOzoneConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
#else
#define emberAfOzoneConcentrationMeasurementClusterPrint(...)
#define emberAfOzoneConcentrationMeasurementClusterPrintln(...)
#define emberAfOzoneConcentrationMeasurementClusterFlush()
#define emberAfOzoneConcentrationMeasurementClusterDebugExec(x)
#define emberAfOzoneConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
#define emberAfOzoneConcentrationMeasurementClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER)


// Printing macros for cluster: Sulfur Dioxide Concentration Measurement
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER)
#define emberAfSulfurDioxideConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
#define emberAfSulfurDioxideConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfSulfurDioxideConcentrationMeasurementClusterFlush()
#define emberAfSulfurDioxideConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; }
#define emberAfSulfurDioxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
#define emberAfSulfurDioxideConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
#else
#define emberAfSulfurDioxideConcentrationMeasurementClusterPrint(...)
#define emberAfSulfurDioxideConcentrationMeasurementClusterPrintln(...)
#define emberAfSulfurDioxideConcentrationMeasurementClusterFlush()
#define emberAfSulfurDioxideConcentrationMeasurementClusterDebugExec(x)
#define emberAfSulfurDioxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
#define emberAfSulfurDioxideConcentrationMeasurementClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER)


// Printing macros for cluster: Dissolved Oxygen Concentration Measurement
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER)
#define emberAfDissolvedOxygenConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
#define emberAfDissolvedOxygenConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfDissolvedOxygenConcentrationMeasurementClusterFlush()
#define emberAfDissolvedOxygenConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; }
#define emberAfDissolvedOxygenConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
#define emberAfDissolvedOxygenConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
#else
#define emberAfDissolvedOxygenConcentrationMeasurementClusterPrint(...)
#define emberAfDissolvedOxygenConcentrationMeasurementClusterPrintln(...)
#define emberAfDissolvedOxygenConcentrationMeasurementClusterFlush()
#define emberAfDissolvedOxygenConcentrationMeasurementClusterDebugExec(x)
#define emberAfDissolvedOxygenConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
#define emberAfDissolvedOxygenConcentrationMeasurementClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER)


// Printing macros for cluster: Bromate Concentration Measurement
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER)
#define emberAfBromateConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
#define emberAfBromateConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfBromateConcentrationMeasurementClusterFlush()
#define emberAfBromateConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; }
#define emberAfBromateConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
#define emberAfBromateConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
#else
#define emberAfBromateConcentrationMeasurementClusterPrint(...)
#define emberAfBromateConcentrationMeasurementClusterPrintln(...)
#define emberAfBromateConcentrationMeasurementClusterFlush()
#define emberAfBromateConcentrationMeasurementClusterDebugExec(x)
#define emberAfBromateConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
#define emberAfBromateConcentrationMeasurementClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER)


// Printing macros for cluster: Chloramines Concentration Measurement
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER)
#define emberAfChloraminesConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
#define emberAfChloraminesConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfChloraminesConcentrationMeasurementClusterFlush()
#define emberAfChloraminesConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; }
#define emberAfChloraminesConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
#define emberAfChloraminesConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
#else
#define emberAfChloraminesConcentrationMeasurementClusterPrint(...)
#define emberAfChloraminesConcentrationMeasurementClusterPrintln(...)
#define emberAfChloraminesConcentrationMeasurementClusterFlush()
#define emberAfChloraminesConcentrationMeasurementClusterDebugExec(x)
#define emberAfChloraminesConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
#define emberAfChloraminesConcentrationMeasurementClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER)


// Printing macros for cluster: Chlorine Concentration Measurement
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER)
#define emberAfChlorineConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
#define emberAfChlorineConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfChlorineConcentrationMeasurementClusterFlush()
#define emberAfChlorineConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; }
#define emberAfChlorineConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
#define emberAfChlorineConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
#else
#define emberAfChlorineConcentrationMeasurementClusterPrint(...)
#define emberAfChlorineConcentrationMeasurementClusterPrintln(...)
#define emberAfChlorineConcentrationMeasurementClusterFlush()
#define emberAfChlorineConcentrationMeasurementClusterDebugExec(x)
#define emberAfChlorineConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
#define emberAfChlorineConcentrationMeasurementClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER)


// Printing macros for cluster: Fecal coliform and E. Coli Concentration Measurement
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER)
#define emberAfFecalColiformAndEColiConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
#define emberAfFecalColiformAndEColiConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfFecalColiformAndEColiConcentrationMeasurementClusterFlush()
#define emberAfFecalColiformAndEColiConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; }
#define emberAfFecalColiformAndEColiConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
#define emberAfFecalColiformAndEColiConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
#else
#define emberAfFecalColiformAndEColiConcentrationMeasurementClusterPrint(...)
#define emberAfFecalColiformAndEColiConcentrationMeasurementClusterPrintln(...)
#define emberAfFecalColiformAndEColiConcentrationMeasurementClusterFlush()
#define emberAfFecalColiformAndEColiConcentrationMeasurementClusterDebugExec(x)
#define emberAfFecalColiformAndEColiConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
#define emberAfFecalColiformAndEColiConcentrationMeasurementClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER)


// Printing macros for cluster: Fluoride Concentration Measurement
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER)
#define emberAfFluorideConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
#define emberAfFluorideConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfFluorideConcentrationMeasurementClusterFlush()
#define emberAfFluorideConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; }
#define emberAfFluorideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
#define emberAfFluorideConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
#else
#define emberAfFluorideConcentrationMeasurementClusterPrint(...)
#define emberAfFluorideConcentrationMeasurementClusterPrintln(...)
#define emberAfFluorideConcentrationMeasurementClusterFlush()
#define emberAfFluorideConcentrationMeasurementClusterDebugExec(x)
#define emberAfFluorideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
#define emberAfFluorideConcentrationMeasurementClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER)


// Printing macros for cluster: Haloacetic Acids Concentration Measurement
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER)
#define emberAfHaloaceticAcidsConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
#define emberAfHaloaceticAcidsConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfHaloaceticAcidsConcentrationMeasurementClusterFlush()
#define emberAfHaloaceticAcidsConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; }
#define emberAfHaloaceticAcidsConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
#define emberAfHaloaceticAcidsConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
#else
#define emberAfHaloaceticAcidsConcentrationMeasurementClusterPrint(...)
#define emberAfHaloaceticAcidsConcentrationMeasurementClusterPrintln(...)
#define emberAfHaloaceticAcidsConcentrationMeasurementClusterFlush()
#define emberAfHaloaceticAcidsConcentrationMeasurementClusterDebugExec(x)
#define emberAfHaloaceticAcidsConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
#define emberAfHaloaceticAcidsConcentrationMeasurementClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER)


// Printing macros for cluster: Total Trihalomethanes Concentration Measurement
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER)
#define emberAfTotalTrihalomethanesConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
#define emberAfTotalTrihalomethanesConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfTotalTrihalomethanesConcentrationMeasurementClusterFlush()
#define emberAfTotalTrihalomethanesConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; }
#define emberAfTotalTrihalomethanesConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
#define emberAfTotalTrihalomethanesConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
#else
#define emberAfTotalTrihalomethanesConcentrationMeasurementClusterPrint(...)
#define emberAfTotalTrihalomethanesConcentrationMeasurementClusterPrintln(...)
#define emberAfTotalTrihalomethanesConcentrationMeasurementClusterFlush()
#define emberAfTotalTrihalomethanesConcentrationMeasurementClusterDebugExec(x)
#define emberAfTotalTrihalomethanesConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
#define emberAfTotalTrihalomethanesConcentrationMeasurementClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER)


// Printing macros for cluster: Total Coliform Bacteria Concentration Measurement
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER)
#define emberAfTotalColiformBacteriaConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
#define emberAfTotalColiformBacteriaConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfTotalColiformBacteriaConcentrationMeasurementClusterFlush()
#define emberAfTotalColiformBacteriaConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; }
#define emberAfTotalColiformBacteriaConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
#define emberAfTotalColiformBacteriaConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
#else
#define emberAfTotalColiformBacteriaConcentrationMeasurementClusterPrint(...)
#define emberAfTotalColiformBacteriaConcentrationMeasurementClusterPrintln(...)
#define emberAfTotalColiformBacteriaConcentrationMeasurementClusterFlush()
#define emberAfTotalColiformBacteriaConcentrationMeasurementClusterDebugExec(x)
#define emberAfTotalColiformBacteriaConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
#define emberAfTotalColiformBacteriaConcentrationMeasurementClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER)


// Printing macros for cluster: Turbidity Concentration Measurement
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER)
#define emberAfTurbidityConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
#define emberAfTurbidityConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfTurbidityConcentrationMeasurementClusterFlush()
#define emberAfTurbidityConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; }
#define emberAfTurbidityConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
#define emberAfTurbidityConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
#else
#define emberAfTurbidityConcentrationMeasurementClusterPrint(...)
#define emberAfTurbidityConcentrationMeasurementClusterPrintln(...)
#define emberAfTurbidityConcentrationMeasurementClusterFlush()
#define emberAfTurbidityConcentrationMeasurementClusterDebugExec(x)
#define emberAfTurbidityConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
#define emberAfTurbidityConcentrationMeasurementClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER)


// Printing macros for cluster: Copper Concentration Measurement
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER)
#define emberAfCopperConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
#define emberAfCopperConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfCopperConcentrationMeasurementClusterFlush()
#define emberAfCopperConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; }
#define emberAfCopperConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
#define emberAfCopperConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
#else
#define emberAfCopperConcentrationMeasurementClusterPrint(...)
#define emberAfCopperConcentrationMeasurementClusterPrintln(...)
#define emberAfCopperConcentrationMeasurementClusterFlush()
#define emberAfCopperConcentrationMeasurementClusterDebugExec(x)
#define emberAfCopperConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
#define emberAfCopperConcentrationMeasurementClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER)


// Printing macros for cluster: Lead Concentration Measurement
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER)
#define emberAfLeadConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
#define emberAfLeadConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfLeadConcentrationMeasurementClusterFlush()
#define emberAfLeadConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; }
#define emberAfLeadConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
#define emberAfLeadConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
#else
#define emberAfLeadConcentrationMeasurementClusterPrint(...)
#define emberAfLeadConcentrationMeasurementClusterPrintln(...)
#define emberAfLeadConcentrationMeasurementClusterFlush()
#define emberAfLeadConcentrationMeasurementClusterDebugExec(x)
#define emberAfLeadConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
#define emberAfLeadConcentrationMeasurementClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER)


// Printing macros for cluster: Manganese Concentration Measurement
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER)
#define emberAfManganeseConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
#define emberAfManganeseConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfManganeseConcentrationMeasurementClusterFlush()
#define emberAfManganeseConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; }
#define emberAfManganeseConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
#define emberAfManganeseConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
#else
#define emberAfManganeseConcentrationMeasurementClusterPrint(...)
#define emberAfManganeseConcentrationMeasurementClusterPrintln(...)
#define emberAfManganeseConcentrationMeasurementClusterFlush()
#define emberAfManganeseConcentrationMeasurementClusterDebugExec(x)
#define emberAfManganeseConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
#define emberAfManganeseConcentrationMeasurementClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER)


// Printing macros for cluster: Sulfate Concentration Measurement
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER)
#define emberAfSulfateConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
#define emberAfSulfateConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfSulfateConcentrationMeasurementClusterFlush()
#define emberAfSulfateConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; }
#define emberAfSulfateConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
#define emberAfSulfateConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
#else
#define emberAfSulfateConcentrationMeasurementClusterPrint(...)
#define emberAfSulfateConcentrationMeasurementClusterPrintln(...)
#define emberAfSulfateConcentrationMeasurementClusterFlush()
#define emberAfSulfateConcentrationMeasurementClusterDebugExec(x)
#define emberAfSulfateConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
#define emberAfSulfateConcentrationMeasurementClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER)


// Printing macros for cluster: Bromodichloromethane Concentration Measurement
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER)
#define emberAfBromodichloromethaneConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
#define emberAfBromodichloromethaneConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfBromodichloromethaneConcentrationMeasurementClusterFlush()
#define emberAfBromodichloromethaneConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; }
#define emberAfBromodichloromethaneConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
#define emberAfBromodichloromethaneConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
#else
#define emberAfBromodichloromethaneConcentrationMeasurementClusterPrint(...)
#define emberAfBromodichloromethaneConcentrationMeasurementClusterPrintln(...)
#define emberAfBromodichloromethaneConcentrationMeasurementClusterFlush()
#define emberAfBromodichloromethaneConcentrationMeasurementClusterDebugExec(x)
#define emberAfBromodichloromethaneConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
#define emberAfBromodichloromethaneConcentrationMeasurementClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER)


// Printing macros for cluster: Bromoform Concentration Measurement
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER)
#define emberAfBromoformConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
#define emberAfBromoformConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfBromoformConcentrationMeasurementClusterFlush()
#define emberAfBromoformConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; }
#define emberAfBromoformConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
#define emberAfBromoformConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
#else
#define emberAfBromoformConcentrationMeasurementClusterPrint(...)
#define emberAfBromoformConcentrationMeasurementClusterPrintln(...)
#define emberAfBromoformConcentrationMeasurementClusterFlush()
#define emberAfBromoformConcentrationMeasurementClusterDebugExec(x)
#define emberAfBromoformConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
#define emberAfBromoformConcentrationMeasurementClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER)


// Printing macros for cluster: Chlorodibromomethane Concentration Measurement
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER)
#define emberAfChlorodibromomethaneConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
#define emberAfChlorodibromomethaneConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfChlorodibromomethaneConcentrationMeasurementClusterFlush()
#define emberAfChlorodibromomethaneConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; }
#define emberAfChlorodibromomethaneConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
#define emberAfChlorodibromomethaneConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
#else
#define emberAfChlorodibromomethaneConcentrationMeasurementClusterPrint(...)
#define emberAfChlorodibromomethaneConcentrationMeasurementClusterPrintln(...)
#define emberAfChlorodibromomethaneConcentrationMeasurementClusterFlush()
#define emberAfChlorodibromomethaneConcentrationMeasurementClusterDebugExec(x)
#define emberAfChlorodibromomethaneConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
#define emberAfChlorodibromomethaneConcentrationMeasurementClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER)


// Printing macros for cluster: Chloroform Concentration Measurement
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER)
#define emberAfChloroformConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
#define emberAfChloroformConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfChloroformConcentrationMeasurementClusterFlush()
#define emberAfChloroformConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; }
#define emberAfChloroformConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
#define emberAfChloroformConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
#else
#define emberAfChloroformConcentrationMeasurementClusterPrint(...)
#define emberAfChloroformConcentrationMeasurementClusterPrintln(...)
#define emberAfChloroformConcentrationMeasurementClusterFlush()
#define emberAfChloroformConcentrationMeasurementClusterDebugExec(x)
#define emberAfChloroformConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
#define emberAfChloroformConcentrationMeasurementClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER)


// Printing macros for cluster: Sodium Concentration Measurement
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER)
#define emberAfSodiumConcentrationMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
#define emberAfSodiumConcentrationMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfSodiumConcentrationMeasurementClusterFlush()
#define emberAfSodiumConcentrationMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER) ) { x; }
#define emberAfSodiumConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
#define emberAfSodiumConcentrationMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
#else
#define emberAfSodiumConcentrationMeasurementClusterPrint(...)
#define emberAfSodiumConcentrationMeasurementClusterPrintln(...)
#define emberAfSodiumConcentrationMeasurementClusterFlush()
#define emberAfSodiumConcentrationMeasurementClusterDebugExec(x)
#define emberAfSodiumConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
#define emberAfSodiumConcentrationMeasurementClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER)


// Printing macros for cluster: IAS Zone
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_IAS_ZONE_CLUSTER)
#define emberAfIasZoneClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_IAS_ZONE_CLUSTER, __VA_ARGS__)
#define emberAfIasZoneClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_IAS_ZONE_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfIasZoneClusterFlush()
#define emberAfIasZoneClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_IAS_ZONE_CLUSTER) ) { x; }
#define emberAfIasZoneClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_IAS_ZONE_CLUSTER, (buffer), (len), (withSpace))
#define emberAfIasZoneClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_IAS_ZONE_CLUSTER, (buffer))
#else
#define emberAfIasZoneClusterPrint(...)
#define emberAfIasZoneClusterPrintln(...)
#define emberAfIasZoneClusterFlush()
#define emberAfIasZoneClusterDebugExec(x)
#define emberAfIasZoneClusterPrintBuffer(buffer, len, withSpace)
#define emberAfIasZoneClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_IAS_ZONE_CLUSTER)


// Printing macros for cluster: IAS ACE
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_IAS_ACE_CLUSTER)
#define emberAfIasAceClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_IAS_ACE_CLUSTER, __VA_ARGS__)
#define emberAfIasAceClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_IAS_ACE_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfIasAceClusterFlush()
#define emberAfIasAceClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_IAS_ACE_CLUSTER) ) { x; }
#define emberAfIasAceClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_IAS_ACE_CLUSTER, (buffer), (len), (withSpace))
#define emberAfIasAceClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_IAS_ACE_CLUSTER, (buffer))
#else
#define emberAfIasAceClusterPrint(...)
#define emberAfIasAceClusterPrintln(...)
#define emberAfIasAceClusterFlush()
#define emberAfIasAceClusterDebugExec(x)
#define emberAfIasAceClusterPrintBuffer(buffer, len, withSpace)
#define emberAfIasAceClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_IAS_ACE_CLUSTER)


// Printing macros for cluster: IAS WD
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_IAS_WD_CLUSTER)
#define emberAfIasWdClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_IAS_WD_CLUSTER, __VA_ARGS__)
#define emberAfIasWdClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_IAS_WD_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfIasWdClusterFlush()
#define emberAfIasWdClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_IAS_WD_CLUSTER) ) { x; }
#define emberAfIasWdClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_IAS_WD_CLUSTER, (buffer), (len), (withSpace))
#define emberAfIasWdClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_IAS_WD_CLUSTER, (buffer))
#else
#define emberAfIasWdClusterPrint(...)
#define emberAfIasWdClusterPrintln(...)
#define emberAfIasWdClusterFlush()
#define emberAfIasWdClusterDebugExec(x)
#define emberAfIasWdClusterPrintBuffer(buffer, len, withSpace)
#define emberAfIasWdClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_IAS_WD_CLUSTER)


// Printing macros for cluster: Generic Tunnel
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_GENERIC_TUNNEL_CLUSTER)
#define emberAfGenericTunnelClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_GENERIC_TUNNEL_CLUSTER, __VA_ARGS__)
#define emberAfGenericTunnelClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_GENERIC_TUNNEL_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfGenericTunnelClusterFlush()
#define emberAfGenericTunnelClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_GENERIC_TUNNEL_CLUSTER) ) { x; }
#define emberAfGenericTunnelClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_GENERIC_TUNNEL_CLUSTER, (buffer), (len), (withSpace))
#define emberAfGenericTunnelClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_GENERIC_TUNNEL_CLUSTER, (buffer))
#else
#define emberAfGenericTunnelClusterPrint(...)
#define emberAfGenericTunnelClusterPrintln(...)
#define emberAfGenericTunnelClusterFlush()
#define emberAfGenericTunnelClusterDebugExec(x)
#define emberAfGenericTunnelClusterPrintBuffer(buffer, len, withSpace)
#define emberAfGenericTunnelClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_GENERIC_TUNNEL_CLUSTER)


// Printing macros for cluster: BACnet Protocol Tunnel
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BACNET_PROTOCOL_TUNNEL_CLUSTER)
#define emberAfBacnetProtocolTunnelClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_BACNET_PROTOCOL_TUNNEL_CLUSTER, __VA_ARGS__)
#define emberAfBacnetProtocolTunnelClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_BACNET_PROTOCOL_TUNNEL_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfBacnetProtocolTunnelClusterFlush()
#define emberAfBacnetProtocolTunnelClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_BACNET_PROTOCOL_TUNNEL_CLUSTER) ) { x; }
#define emberAfBacnetProtocolTunnelClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_BACNET_PROTOCOL_TUNNEL_CLUSTER, (buffer), (len), (withSpace))
#define emberAfBacnetProtocolTunnelClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_BACNET_PROTOCOL_TUNNEL_CLUSTER, (buffer))
#else
#define emberAfBacnetProtocolTunnelClusterPrint(...)
#define emberAfBacnetProtocolTunnelClusterPrintln(...)
#define emberAfBacnetProtocolTunnelClusterFlush()
#define emberAfBacnetProtocolTunnelClusterDebugExec(x)
#define emberAfBacnetProtocolTunnelClusterPrintBuffer(buffer, len, withSpace)
#define emberAfBacnetProtocolTunnelClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BACNET_PROTOCOL_TUNNEL_CLUSTER)


// Printing macros for cluster: 11073 Protocol Tunnel
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_11073_PROTOCOL_TUNNEL_CLUSTER)
#define emberAf11073ProtocolTunnelClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_11073_PROTOCOL_TUNNEL_CLUSTER, __VA_ARGS__)
#define emberAf11073ProtocolTunnelClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_11073_PROTOCOL_TUNNEL_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAf11073ProtocolTunnelClusterFlush()
#define emberAf11073ProtocolTunnelClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_11073_PROTOCOL_TUNNEL_CLUSTER) ) { x; }
#define emberAf11073ProtocolTunnelClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_11073_PROTOCOL_TUNNEL_CLUSTER, (buffer), (len), (withSpace))
#define emberAf11073ProtocolTunnelClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_11073_PROTOCOL_TUNNEL_CLUSTER, (buffer))
#else
#define emberAf11073ProtocolTunnelClusterPrint(...)
#define emberAf11073ProtocolTunnelClusterPrintln(...)
#define emberAf11073ProtocolTunnelClusterFlush()
#define emberAf11073ProtocolTunnelClusterDebugExec(x)
#define emberAf11073ProtocolTunnelClusterPrintBuffer(buffer, len, withSpace)
#define emberAf11073ProtocolTunnelClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_11073_PROTOCOL_TUNNEL_CLUSTER)


// Printing macros for cluster: ISO 7816 Protocol Tunnel
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ISO7816_PROTOCOL_TUNNEL_CLUSTER)
#define emberAfIso7816ProtocolTunnelClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ISO7816_PROTOCOL_TUNNEL_CLUSTER, __VA_ARGS__)
#define emberAfIso7816ProtocolTunnelClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ISO7816_PROTOCOL_TUNNEL_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfIso7816ProtocolTunnelClusterFlush()
#define emberAfIso7816ProtocolTunnelClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_ISO7816_PROTOCOL_TUNNEL_CLUSTER) ) { x; }
#define emberAfIso7816ProtocolTunnelClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_ISO7816_PROTOCOL_TUNNEL_CLUSTER, (buffer), (len), (withSpace))
#define emberAfIso7816ProtocolTunnelClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ISO7816_PROTOCOL_TUNNEL_CLUSTER, (buffer))
#else
#define emberAfIso7816ProtocolTunnelClusterPrint(...)
#define emberAfIso7816ProtocolTunnelClusterPrintln(...)
#define emberAfIso7816ProtocolTunnelClusterFlush()
#define emberAfIso7816ProtocolTunnelClusterDebugExec(x)
#define emberAfIso7816ProtocolTunnelClusterPrintBuffer(buffer, len, withSpace)
#define emberAfIso7816ProtocolTunnelClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ISO7816_PROTOCOL_TUNNEL_CLUSTER)


// Printing macros for cluster: Price
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PRICE_CLUSTER)
#define emberAfPriceClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_PRICE_CLUSTER, __VA_ARGS__)
#define emberAfPriceClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_PRICE_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfPriceClusterFlush()
#define emberAfPriceClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_PRICE_CLUSTER) ) { x; }
#define emberAfPriceClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_PRICE_CLUSTER, (buffer), (len), (withSpace))
#define emberAfPriceClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_PRICE_CLUSTER, (buffer))
#else
#define emberAfPriceClusterPrint(...)
#define emberAfPriceClusterPrintln(...)
#define emberAfPriceClusterFlush()
#define emberAfPriceClusterDebugExec(x)
#define emberAfPriceClusterPrintBuffer(buffer, len, withSpace)
#define emberAfPriceClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PRICE_CLUSTER)


// Printing macros for cluster: Demand Response and Load Control
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER)
#define emberAfDemandResponseLoadControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER, __VA_ARGS__)
#define emberAfDemandResponseLoadControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfDemandResponseLoadControlClusterFlush()
#define emberAfDemandResponseLoadControlClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER) ) { x; }
#define emberAfDemandResponseLoadControlClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER, (buffer), (len), (withSpace))
#define emberAfDemandResponseLoadControlClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER, (buffer))
#else
#define emberAfDemandResponseLoadControlClusterPrint(...)
#define emberAfDemandResponseLoadControlClusterPrintln(...)
#define emberAfDemandResponseLoadControlClusterFlush()
#define emberAfDemandResponseLoadControlClusterDebugExec(x)
#define emberAfDemandResponseLoadControlClusterPrintBuffer(buffer, len, withSpace)
#define emberAfDemandResponseLoadControlClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER)


// Printing macros for cluster: Simple Metering
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SIMPLE_METERING_CLUSTER)
#define emberAfSimpleMeteringClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_SIMPLE_METERING_CLUSTER, __VA_ARGS__)
#define emberAfSimpleMeteringClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SIMPLE_METERING_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfSimpleMeteringClusterFlush()
#define emberAfSimpleMeteringClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_SIMPLE_METERING_CLUSTER) ) { x; }
#define emberAfSimpleMeteringClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_SIMPLE_METERING_CLUSTER, (buffer), (len), (withSpace))
#define emberAfSimpleMeteringClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SIMPLE_METERING_CLUSTER, (buffer))
#else
#define emberAfSimpleMeteringClusterPrint(...)
#define emberAfSimpleMeteringClusterPrintln(...)
#define emberAfSimpleMeteringClusterFlush()
#define emberAfSimpleMeteringClusterDebugExec(x)
#define emberAfSimpleMeteringClusterPrintBuffer(buffer, len, withSpace)
#define emberAfSimpleMeteringClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SIMPLE_METERING_CLUSTER)


// Printing macros for cluster: Messaging
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_MESSAGING_CLUSTER)
#define emberAfMessagingClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_MESSAGING_CLUSTER, __VA_ARGS__)
#define emberAfMessagingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_MESSAGING_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfMessagingClusterFlush()
#define emberAfMessagingClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_MESSAGING_CLUSTER) ) { x; }
#define emberAfMessagingClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_MESSAGING_CLUSTER, (buffer), (len), (withSpace))
#define emberAfMessagingClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_MESSAGING_CLUSTER, (buffer))
#else
#define emberAfMessagingClusterPrint(...)
#define emberAfMessagingClusterPrintln(...)
#define emberAfMessagingClusterFlush()
#define emberAfMessagingClusterDebugExec(x)
#define emberAfMessagingClusterPrintBuffer(buffer, len, withSpace)
#define emberAfMessagingClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_MESSAGING_CLUSTER)


// Printing macros for cluster: Tunneling
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TUNNELING_CLUSTER)
#define emberAfTunnelingClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_TUNNELING_CLUSTER, __VA_ARGS__)
#define emberAfTunnelingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_TUNNELING_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfTunnelingClusterFlush()
#define emberAfTunnelingClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_TUNNELING_CLUSTER) ) { x; }
#define emberAfTunnelingClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_TUNNELING_CLUSTER, (buffer), (len), (withSpace))
#define emberAfTunnelingClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_TUNNELING_CLUSTER, (buffer))
#else
#define emberAfTunnelingClusterPrint(...)
#define emberAfTunnelingClusterPrintln(...)
#define emberAfTunnelingClusterFlush()
#define emberAfTunnelingClusterDebugExec(x)
#define emberAfTunnelingClusterPrintBuffer(buffer, len, withSpace)
#define emberAfTunnelingClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TUNNELING_CLUSTER)


// Printing macros for cluster: Prepayment
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PREPAYMENT_CLUSTER)
#define emberAfPrepaymentClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_PREPAYMENT_CLUSTER, __VA_ARGS__)
#define emberAfPrepaymentClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_PREPAYMENT_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfPrepaymentClusterFlush()
#define emberAfPrepaymentClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_PREPAYMENT_CLUSTER) ) { x; }
#define emberAfPrepaymentClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_PREPAYMENT_CLUSTER, (buffer), (len), (withSpace))
#define emberAfPrepaymentClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_PREPAYMENT_CLUSTER, (buffer))
#else
#define emberAfPrepaymentClusterPrint(...)
#define emberAfPrepaymentClusterPrintln(...)
#define emberAfPrepaymentClusterFlush()
#define emberAfPrepaymentClusterDebugExec(x)
#define emberAfPrepaymentClusterPrintBuffer(buffer, len, withSpace)
#define emberAfPrepaymentClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PREPAYMENT_CLUSTER)


// Printing macros for cluster: Energy Management
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ENERGY_MANAGEMENT_CLUSTER)
#define emberAfEnergyManagementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ENERGY_MANAGEMENT_CLUSTER, __VA_ARGS__)
#define emberAfEnergyManagementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ENERGY_MANAGEMENT_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfEnergyManagementClusterFlush()
#define emberAfEnergyManagementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_ENERGY_MANAGEMENT_CLUSTER) ) { x; }
#define emberAfEnergyManagementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_ENERGY_MANAGEMENT_CLUSTER, (buffer), (len), (withSpace))
#define emberAfEnergyManagementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ENERGY_MANAGEMENT_CLUSTER, (buffer))
#else
#define emberAfEnergyManagementClusterPrint(...)
#define emberAfEnergyManagementClusterPrintln(...)
#define emberAfEnergyManagementClusterFlush()
#define emberAfEnergyManagementClusterDebugExec(x)
#define emberAfEnergyManagementClusterPrintBuffer(buffer, len, withSpace)
#define emberAfEnergyManagementClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ENERGY_MANAGEMENT_CLUSTER)


// Printing macros for cluster: Calendar
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CALENDAR_CLUSTER)
#define emberAfCalendarClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_CALENDAR_CLUSTER, __VA_ARGS__)
#define emberAfCalendarClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_CALENDAR_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfCalendarClusterFlush()
#define emberAfCalendarClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_CALENDAR_CLUSTER) ) { x; }
#define emberAfCalendarClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_CALENDAR_CLUSTER, (buffer), (len), (withSpace))
#define emberAfCalendarClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_CALENDAR_CLUSTER, (buffer))
#else
#define emberAfCalendarClusterPrint(...)
#define emberAfCalendarClusterPrintln(...)
#define emberAfCalendarClusterFlush()
#define emberAfCalendarClusterDebugExec(x)
#define emberAfCalendarClusterPrintBuffer(buffer, len, withSpace)
#define emberAfCalendarClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CALENDAR_CLUSTER)


// Printing macros for cluster: Device Management
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEVICE_MANAGEMENT_CLUSTER)
#define emberAfDeviceManagementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_DEVICE_MANAGEMENT_CLUSTER, __VA_ARGS__)
#define emberAfDeviceManagementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DEVICE_MANAGEMENT_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfDeviceManagementClusterFlush()
#define emberAfDeviceManagementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_DEVICE_MANAGEMENT_CLUSTER) ) { x; }
#define emberAfDeviceManagementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_DEVICE_MANAGEMENT_CLUSTER, (buffer), (len), (withSpace))
#define emberAfDeviceManagementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_DEVICE_MANAGEMENT_CLUSTER, (buffer))
#else
#define emberAfDeviceManagementClusterPrint(...)
#define emberAfDeviceManagementClusterPrintln(...)
#define emberAfDeviceManagementClusterFlush()
#define emberAfDeviceManagementClusterDebugExec(x)
#define emberAfDeviceManagementClusterPrintBuffer(buffer, len, withSpace)
#define emberAfDeviceManagementClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEVICE_MANAGEMENT_CLUSTER)


// Printing macros for cluster: Events
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_EVENTS_CLUSTER)
#define emberAfEventsClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_EVENTS_CLUSTER, __VA_ARGS__)
#define emberAfEventsClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_EVENTS_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfEventsClusterFlush()
#define emberAfEventsClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_EVENTS_CLUSTER) ) { x; }
#define emberAfEventsClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_EVENTS_CLUSTER, (buffer), (len), (withSpace))
#define emberAfEventsClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_EVENTS_CLUSTER, (buffer))
#else
#define emberAfEventsClusterPrint(...)
#define emberAfEventsClusterPrintln(...)
#define emberAfEventsClusterFlush()
#define emberAfEventsClusterDebugExec(x)
#define emberAfEventsClusterPrintBuffer(buffer, len, withSpace)
#define emberAfEventsClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_EVENTS_CLUSTER)


// Printing macros for cluster: MDU Pairing
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_MDU_PAIRING_CLUSTER)
#define emberAfMduPairingClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_MDU_PAIRING_CLUSTER, __VA_ARGS__)
#define emberAfMduPairingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_MDU_PAIRING_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfMduPairingClusterFlush()
#define emberAfMduPairingClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_MDU_PAIRING_CLUSTER) ) { x; }
#define emberAfMduPairingClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_MDU_PAIRING_CLUSTER, (buffer), (len), (withSpace))
#define emberAfMduPairingClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_MDU_PAIRING_CLUSTER, (buffer))
#else
#define emberAfMduPairingClusterPrint(...)
#define emberAfMduPairingClusterPrintln(...)
#define emberAfMduPairingClusterFlush()
#define emberAfMduPairingClusterDebugExec(x)
#define emberAfMduPairingClusterPrintBuffer(buffer, len, withSpace)
#define emberAfMduPairingClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_MDU_PAIRING_CLUSTER)


// Printing macros for cluster: Sub-GHz
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SUB_GHZ_CLUSTER)
#define emberAfSubGhzClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_SUB_GHZ_CLUSTER, __VA_ARGS__)
#define emberAfSubGhzClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SUB_GHZ_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfSubGhzClusterFlush()
#define emberAfSubGhzClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_SUB_GHZ_CLUSTER) ) { x; }
#define emberAfSubGhzClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_SUB_GHZ_CLUSTER, (buffer), (len), (withSpace))
#define emberAfSubGhzClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SUB_GHZ_CLUSTER, (buffer))
#else
#define emberAfSubGhzClusterPrint(...)
#define emberAfSubGhzClusterPrintln(...)
#define emberAfSubGhzClusterFlush()
#define emberAfSubGhzClusterDebugExec(x)
#define emberAfSubGhzClusterPrintBuffer(buffer, len, withSpace)
#define emberAfSubGhzClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SUB_GHZ_CLUSTER)


// Printing macros for cluster: Key Establishment
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_KEY_ESTABLISHMENT_CLUSTER)
#define emberAfKeyEstablishmentClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_KEY_ESTABLISHMENT_CLUSTER, __VA_ARGS__)
#define emberAfKeyEstablishmentClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_KEY_ESTABLISHMENT_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfKeyEstablishmentClusterFlush()
#define emberAfKeyEstablishmentClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_KEY_ESTABLISHMENT_CLUSTER) ) { x; }
#define emberAfKeyEstablishmentClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_KEY_ESTABLISHMENT_CLUSTER, (buffer), (len), (withSpace))
#define emberAfKeyEstablishmentClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_KEY_ESTABLISHMENT_CLUSTER, (buffer))
#else
#define emberAfKeyEstablishmentClusterPrint(...)
#define emberAfKeyEstablishmentClusterPrintln(...)
#define emberAfKeyEstablishmentClusterFlush()
#define emberAfKeyEstablishmentClusterDebugExec(x)
#define emberAfKeyEstablishmentClusterPrintBuffer(buffer, len, withSpace)
#define emberAfKeyEstablishmentClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_KEY_ESTABLISHMENT_CLUSTER)


// Printing macros for cluster: Information
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_INFORMATION_CLUSTER)
#define emberAfInformationClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_INFORMATION_CLUSTER, __VA_ARGS__)
#define emberAfInformationClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_INFORMATION_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfInformationClusterFlush()
#define emberAfInformationClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_INFORMATION_CLUSTER) ) { x; }
#define emberAfInformationClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_INFORMATION_CLUSTER, (buffer), (len), (withSpace))
#define emberAfInformationClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_INFORMATION_CLUSTER, (buffer))
#else
#define emberAfInformationClusterPrint(...)
#define emberAfInformationClusterPrintln(...)
#define emberAfInformationClusterFlush()
#define emberAfInformationClusterDebugExec(x)
#define emberAfInformationClusterPrintBuffer(buffer, len, withSpace)
#define emberAfInformationClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_INFORMATION_CLUSTER)


// Printing macros for cluster: Data Sharing
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DATA_SHARING_CLUSTER)
#define emberAfDataSharingClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_DATA_SHARING_CLUSTER, __VA_ARGS__)
#define emberAfDataSharingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DATA_SHARING_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfDataSharingClusterFlush()
#define emberAfDataSharingClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_DATA_SHARING_CLUSTER) ) { x; }
#define emberAfDataSharingClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_DATA_SHARING_CLUSTER, (buffer), (len), (withSpace))
#define emberAfDataSharingClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_DATA_SHARING_CLUSTER, (buffer))
#else
#define emberAfDataSharingClusterPrint(...)
#define emberAfDataSharingClusterPrintln(...)
#define emberAfDataSharingClusterFlush()
#define emberAfDataSharingClusterDebugExec(x)
#define emberAfDataSharingClusterPrintBuffer(buffer, len, withSpace)
#define emberAfDataSharingClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DATA_SHARING_CLUSTER)


// Printing macros for cluster: Gaming
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_GAMING_CLUSTER)
#define emberAfGamingClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_GAMING_CLUSTER, __VA_ARGS__)
#define emberAfGamingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_GAMING_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfGamingClusterFlush()
#define emberAfGamingClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_GAMING_CLUSTER) ) { x; }
#define emberAfGamingClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_GAMING_CLUSTER, (buffer), (len), (withSpace))
#define emberAfGamingClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_GAMING_CLUSTER, (buffer))
#else
#define emberAfGamingClusterPrint(...)
#define emberAfGamingClusterPrintln(...)
#define emberAfGamingClusterFlush()
#define emberAfGamingClusterDebugExec(x)
#define emberAfGamingClusterPrintBuffer(buffer, len, withSpace)
#define emberAfGamingClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_GAMING_CLUSTER)


// Printing macros for cluster: Data Rate Control
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DATA_RATE_CONTROL_CLUSTER)
#define emberAfDataRateControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_DATA_RATE_CONTROL_CLUSTER, __VA_ARGS__)
#define emberAfDataRateControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DATA_RATE_CONTROL_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfDataRateControlClusterFlush()
#define emberAfDataRateControlClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_DATA_RATE_CONTROL_CLUSTER) ) { x; }
#define emberAfDataRateControlClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_DATA_RATE_CONTROL_CLUSTER, (buffer), (len), (withSpace))
#define emberAfDataRateControlClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_DATA_RATE_CONTROL_CLUSTER, (buffer))
#else
#define emberAfDataRateControlClusterPrint(...)
#define emberAfDataRateControlClusterPrintln(...)
#define emberAfDataRateControlClusterFlush()
#define emberAfDataRateControlClusterDebugExec(x)
#define emberAfDataRateControlClusterPrintBuffer(buffer, len, withSpace)
#define emberAfDataRateControlClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DATA_RATE_CONTROL_CLUSTER)


// Printing macros for cluster: Voice over ZigBee
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_VOICE_OVER_ZIGBEE_CLUSTER)
#define emberAfVoiceOverZigbeeClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_VOICE_OVER_ZIGBEE_CLUSTER, __VA_ARGS__)
#define emberAfVoiceOverZigbeeClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_VOICE_OVER_ZIGBEE_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfVoiceOverZigbeeClusterFlush()
#define emberAfVoiceOverZigbeeClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_VOICE_OVER_ZIGBEE_CLUSTER) ) { x; }
#define emberAfVoiceOverZigbeeClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_VOICE_OVER_ZIGBEE_CLUSTER, (buffer), (len), (withSpace))
#define emberAfVoiceOverZigbeeClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_VOICE_OVER_ZIGBEE_CLUSTER, (buffer))
#else
#define emberAfVoiceOverZigbeeClusterPrint(...)
#define emberAfVoiceOverZigbeeClusterPrintln(...)
#define emberAfVoiceOverZigbeeClusterFlush()
#define emberAfVoiceOverZigbeeClusterDebugExec(x)
#define emberAfVoiceOverZigbeeClusterPrintBuffer(buffer, len, withSpace)
#define emberAfVoiceOverZigbeeClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_VOICE_OVER_ZIGBEE_CLUSTER)


// Printing macros for cluster: Chatting
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHATTING_CLUSTER)
#define emberAfChattingClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_CHATTING_CLUSTER, __VA_ARGS__)
#define emberAfChattingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_CHATTING_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfChattingClusterFlush()
#define emberAfChattingClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_CHATTING_CLUSTER) ) { x; }
#define emberAfChattingClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_CHATTING_CLUSTER, (buffer), (len), (withSpace))
#define emberAfChattingClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_CHATTING_CLUSTER, (buffer))
#else
#define emberAfChattingClusterPrint(...)
#define emberAfChattingClusterPrintln(...)
#define emberAfChattingClusterFlush()
#define emberAfChattingClusterDebugExec(x)
#define emberAfChattingClusterPrintBuffer(buffer, len, withSpace)
#define emberAfChattingClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHATTING_CLUSTER)


// Printing macros for cluster: Payment
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PAYMENT_CLUSTER)
#define emberAfPaymentClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_PAYMENT_CLUSTER, __VA_ARGS__)
#define emberAfPaymentClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_PAYMENT_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfPaymentClusterFlush()
#define emberAfPaymentClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_PAYMENT_CLUSTER) ) { x; }
#define emberAfPaymentClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_PAYMENT_CLUSTER, (buffer), (len), (withSpace))
#define emberAfPaymentClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_PAYMENT_CLUSTER, (buffer))
#else
#define emberAfPaymentClusterPrint(...)
#define emberAfPaymentClusterPrintln(...)
#define emberAfPaymentClusterFlush()
#define emberAfPaymentClusterDebugExec(x)
#define emberAfPaymentClusterPrintBuffer(buffer, len, withSpace)
#define emberAfPaymentClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PAYMENT_CLUSTER)


// Printing macros for cluster: Billing
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BILLING_CLUSTER)
#define emberAfBillingClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_BILLING_CLUSTER, __VA_ARGS__)
#define emberAfBillingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_BILLING_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfBillingClusterFlush()
#define emberAfBillingClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_BILLING_CLUSTER) ) { x; }
#define emberAfBillingClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_BILLING_CLUSTER, (buffer), (len), (withSpace))
#define emberAfBillingClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_BILLING_CLUSTER, (buffer))
#else
#define emberAfBillingClusterPrint(...)
#define emberAfBillingClusterPrintln(...)
#define emberAfBillingClusterFlush()
#define emberAfBillingClusterDebugExec(x)
#define emberAfBillingClusterPrintBuffer(buffer, len, withSpace)
#define emberAfBillingClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BILLING_CLUSTER)


// Printing macros for cluster: Appliance Identification
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APPLIANCE_IDENTIFICATION_CLUSTER)
#define emberAfApplianceIdentificationClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_APPLIANCE_IDENTIFICATION_CLUSTER, __VA_ARGS__)
#define emberAfApplianceIdentificationClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_APPLIANCE_IDENTIFICATION_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfApplianceIdentificationClusterFlush()
#define emberAfApplianceIdentificationClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_APPLIANCE_IDENTIFICATION_CLUSTER) ) { x; }
#define emberAfApplianceIdentificationClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_APPLIANCE_IDENTIFICATION_CLUSTER, (buffer), (len), (withSpace))
#define emberAfApplianceIdentificationClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_APPLIANCE_IDENTIFICATION_CLUSTER, (buffer))
#else
#define emberAfApplianceIdentificationClusterPrint(...)
#define emberAfApplianceIdentificationClusterPrintln(...)
#define emberAfApplianceIdentificationClusterFlush()
#define emberAfApplianceIdentificationClusterDebugExec(x)
#define emberAfApplianceIdentificationClusterPrintBuffer(buffer, len, withSpace)
#define emberAfApplianceIdentificationClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APPLIANCE_IDENTIFICATION_CLUSTER)


// Printing macros for cluster: Meter Identification
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_METER_IDENTIFICATION_CLUSTER)
#define emberAfMeterIdentificationClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_METER_IDENTIFICATION_CLUSTER, __VA_ARGS__)
#define emberAfMeterIdentificationClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_METER_IDENTIFICATION_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfMeterIdentificationClusterFlush()
#define emberAfMeterIdentificationClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_METER_IDENTIFICATION_CLUSTER) ) { x; }
#define emberAfMeterIdentificationClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_METER_IDENTIFICATION_CLUSTER, (buffer), (len), (withSpace))
#define emberAfMeterIdentificationClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_METER_IDENTIFICATION_CLUSTER, (buffer))
#else
#define emberAfMeterIdentificationClusterPrint(...)
#define emberAfMeterIdentificationClusterPrintln(...)
#define emberAfMeterIdentificationClusterFlush()
#define emberAfMeterIdentificationClusterDebugExec(x)
#define emberAfMeterIdentificationClusterPrintBuffer(buffer, len, withSpace)
#define emberAfMeterIdentificationClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_METER_IDENTIFICATION_CLUSTER)


// Printing macros for cluster: Appliance Events and Alert
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APPLIANCE_EVENTS_AND_ALERT_CLUSTER)
#define emberAfApplianceEventsAndAlertClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_APPLIANCE_EVENTS_AND_ALERT_CLUSTER, __VA_ARGS__)
#define emberAfApplianceEventsAndAlertClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_APPLIANCE_EVENTS_AND_ALERT_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfApplianceEventsAndAlertClusterFlush()
#define emberAfApplianceEventsAndAlertClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_APPLIANCE_EVENTS_AND_ALERT_CLUSTER) ) { x; }
#define emberAfApplianceEventsAndAlertClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_APPLIANCE_EVENTS_AND_ALERT_CLUSTER, (buffer), (len), (withSpace))
#define emberAfApplianceEventsAndAlertClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_APPLIANCE_EVENTS_AND_ALERT_CLUSTER, (buffer))
#else
#define emberAfApplianceEventsAndAlertClusterPrint(...)
#define emberAfApplianceEventsAndAlertClusterPrintln(...)
#define emberAfApplianceEventsAndAlertClusterFlush()
#define emberAfApplianceEventsAndAlertClusterDebugExec(x)
#define emberAfApplianceEventsAndAlertClusterPrintBuffer(buffer, len, withSpace)
#define emberAfApplianceEventsAndAlertClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APPLIANCE_EVENTS_AND_ALERT_CLUSTER)


// Printing macros for cluster: Appliance Statistics
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APPLIANCE_STATISTICS_CLUSTER)
#define emberAfApplianceStatisticsClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_APPLIANCE_STATISTICS_CLUSTER, __VA_ARGS__)
#define emberAfApplianceStatisticsClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_APPLIANCE_STATISTICS_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfApplianceStatisticsClusterFlush()
#define emberAfApplianceStatisticsClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_APPLIANCE_STATISTICS_CLUSTER) ) { x; }
#define emberAfApplianceStatisticsClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_APPLIANCE_STATISTICS_CLUSTER, (buffer), (len), (withSpace))
#define emberAfApplianceStatisticsClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_APPLIANCE_STATISTICS_CLUSTER, (buffer))
#else
#define emberAfApplianceStatisticsClusterPrint(...)
#define emberAfApplianceStatisticsClusterPrintln(...)
#define emberAfApplianceStatisticsClusterFlush()
#define emberAfApplianceStatisticsClusterDebugExec(x)
#define emberAfApplianceStatisticsClusterPrintBuffer(buffer, len, withSpace)
#define emberAfApplianceStatisticsClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APPLIANCE_STATISTICS_CLUSTER)


// Printing macros for cluster: Electrical Measurement
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ELECTRICAL_MEASUREMENT_CLUSTER)
#define emberAfElectricalMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ELECTRICAL_MEASUREMENT_CLUSTER, __VA_ARGS__)
#define emberAfElectricalMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ELECTRICAL_MEASUREMENT_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfElectricalMeasurementClusterFlush()
#define emberAfElectricalMeasurementClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_ELECTRICAL_MEASUREMENT_CLUSTER) ) { x; }
#define emberAfElectricalMeasurementClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_ELECTRICAL_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
#define emberAfElectricalMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ELECTRICAL_MEASUREMENT_CLUSTER, (buffer))
#else
#define emberAfElectricalMeasurementClusterPrint(...)
#define emberAfElectricalMeasurementClusterPrintln(...)
#define emberAfElectricalMeasurementClusterFlush()
#define emberAfElectricalMeasurementClusterDebugExec(x)
#define emberAfElectricalMeasurementClusterPrintBuffer(buffer, len, withSpace)
#define emberAfElectricalMeasurementClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ELECTRICAL_MEASUREMENT_CLUSTER)


// Printing macros for cluster: Diagnostics
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DIAGNOSTICS_CLUSTER)
#define emberAfDiagnosticsClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_DIAGNOSTICS_CLUSTER, __VA_ARGS__)
#define emberAfDiagnosticsClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DIAGNOSTICS_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfDiagnosticsClusterFlush()
#define emberAfDiagnosticsClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_DIAGNOSTICS_CLUSTER) ) { x; }
#define emberAfDiagnosticsClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_DIAGNOSTICS_CLUSTER, (buffer), (len), (withSpace))
#define emberAfDiagnosticsClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_DIAGNOSTICS_CLUSTER, (buffer))
#else
#define emberAfDiagnosticsClusterPrint(...)
#define emberAfDiagnosticsClusterPrintln(...)
#define emberAfDiagnosticsClusterFlush()
#define emberAfDiagnosticsClusterDebugExec(x)
#define emberAfDiagnosticsClusterPrintBuffer(buffer, len, withSpace)
#define emberAfDiagnosticsClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DIAGNOSTICS_CLUSTER)


// Printing macros for cluster: ZLL Commissioning
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ZLL_COMMISSIONING_CLUSTER)
#define emberAfZllCommissioningClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ZLL_COMMISSIONING_CLUSTER, __VA_ARGS__)
#define emberAfZllCommissioningClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ZLL_COMMISSIONING_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfZllCommissioningClusterFlush()
#define emberAfZllCommissioningClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_ZLL_COMMISSIONING_CLUSTER) ) { x; }
#define emberAfZllCommissioningClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_ZLL_COMMISSIONING_CLUSTER, (buffer), (len), (withSpace))
#define emberAfZllCommissioningClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ZLL_COMMISSIONING_CLUSTER, (buffer))
#else
#define emberAfZllCommissioningClusterPrint(...)
#define emberAfZllCommissioningClusterPrintln(...)
#define emberAfZllCommissioningClusterFlush()
#define emberAfZllCommissioningClusterDebugExec(x)
#define emberAfZllCommissioningClusterPrintBuffer(buffer, len, withSpace)
#define emberAfZllCommissioningClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ZLL_COMMISSIONING_CLUSTER)


// Printing macros for cluster: Sample Mfg Specific Cluster
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER)
#define emberAfSampleMfgSpecificClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER, __VA_ARGS__)
#define emberAfSampleMfgSpecificClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfSampleMfgSpecificClusterFlush()
#define emberAfSampleMfgSpecificClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER) ) { x; }
#define emberAfSampleMfgSpecificClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER, (buffer), (len), (withSpace))
#define emberAfSampleMfgSpecificClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER, (buffer))
#else
#define emberAfSampleMfgSpecificClusterPrint(...)
#define emberAfSampleMfgSpecificClusterPrintln(...)
#define emberAfSampleMfgSpecificClusterFlush()
#define emberAfSampleMfgSpecificClusterDebugExec(x)
#define emberAfSampleMfgSpecificClusterPrintBuffer(buffer, len, withSpace)
#define emberAfSampleMfgSpecificClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER)


// Printing macros for cluster: Configuration Cluster
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OTA_CONFIGURATION_CLUSTER)
#define emberAfOtaConfigurationClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_OTA_CONFIGURATION_CLUSTER, __VA_ARGS__)
#define emberAfOtaConfigurationClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_OTA_CONFIGURATION_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfOtaConfigurationClusterFlush()
#define emberAfOtaConfigurationClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_OTA_CONFIGURATION_CLUSTER) ) { x; }
#define emberAfOtaConfigurationClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_OTA_CONFIGURATION_CLUSTER, (buffer), (len), (withSpace))
#define emberAfOtaConfigurationClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_OTA_CONFIGURATION_CLUSTER, (buffer))
#else
#define emberAfOtaConfigurationClusterPrint(...)
#define emberAfOtaConfigurationClusterPrintln(...)
#define emberAfOtaConfigurationClusterFlush()
#define emberAfOtaConfigurationClusterDebugExec(x)
#define emberAfOtaConfigurationClusterPrintBuffer(buffer, len, withSpace)
#define emberAfOtaConfigurationClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OTA_CONFIGURATION_CLUSTER)


// Printing macros for cluster: MFGLIB Cluster
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_MFGLIB_CLUSTER)
#define emberAfMfglibClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_MFGLIB_CLUSTER, __VA_ARGS__)
#define emberAfMfglibClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_MFGLIB_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfMfglibClusterFlush()
#define emberAfMfglibClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_MFGLIB_CLUSTER) ) { x; }
#define emberAfMfglibClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_MFGLIB_CLUSTER, (buffer), (len), (withSpace))
#define emberAfMfglibClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_MFGLIB_CLUSTER, (buffer))
#else
#define emberAfMfglibClusterPrint(...)
#define emberAfMfglibClusterPrintln(...)
#define emberAfMfglibClusterFlush()
#define emberAfMfglibClusterDebugExec(x)
#define emberAfMfglibClusterPrintBuffer(buffer, len, withSpace)
#define emberAfMfglibClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_MFGLIB_CLUSTER)


// Printing macros for cluster: SL Works With All Hubs
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SL_WWAH_CLUSTER)
#define emberAfSlWwahClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_SL_WWAH_CLUSTER, __VA_ARGS__)
#define emberAfSlWwahClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SL_WWAH_CLUSTER,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfSlWwahClusterFlush()
#define emberAfSlWwahClusterDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_SL_WWAH_CLUSTER) ) { x; }
#define emberAfSlWwahClusterPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_SL_WWAH_CLUSTER, (buffer), (len), (withSpace))
#define emberAfSlWwahClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SL_WWAH_CLUSTER, (buffer))
#else
#define emberAfSlWwahClusterPrint(...)
#define emberAfSlWwahClusterPrintln(...)
#define emberAfSlWwahClusterFlush()
#define emberAfSlWwahClusterDebugExec(x)
#define emberAfSlWwahClusterPrintBuffer(buffer, len, withSpace)
#define emberAfSlWwahClusterPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SL_WWAH_CLUSTER)


// Printing macros for Core
// Prints messages for global flow of the receive/send
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CORE)


#define emberAfCoreDebug(...) UTIL_LOG_DBG(__VA_ARGS__)


#define emberAfCorePrint(...) emberAfPrint(EMBER_AF_PRINT_CORE, __VA_ARGS__)
#define emberAfCorePrintln(...) emberAfPrintln(EMBER_AF_PRINT_CORE,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfCoreFlush()
#define emberAfCoreDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_CORE) ) { x; }
#define emberAfCorePrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_CORE, (buffer), (len), (withSpace))
#define emberAfCorePrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_CORE, (buffer))
#else
#define emberAfCorePrint(...)
#define emberAfCorePrintln(...)
#define emberAfCoreFlush()
#define emberAfCoreDebugExec(x)
#define emberAfCorePrintBuffer(buffer, len, withSpace)
#define emberAfCorePrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CORE)


// Printing macros for Debug
// Prints messages for random debugging
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEBUG)
#define emberAfDebugPrint(...) emberAfPrint(EMBER_AF_PRINT_DEBUG, __VA_ARGS__)
#define emberAfDebugPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DEBUG,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfDebugFlush()
#define emberAfDebugDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_DEBUG) ) { x; }
#define emberAfDebugPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_DEBUG, (buffer), (len), (withSpace))
#define emberAfDebugPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_DEBUG, (buffer))
#else
#define emberAfDebugPrint(...)
#define emberAfDebugPrintln(...)
#define emberAfDebugFlush()
#define emberAfDebugDebugExec(x)
#define emberAfDebugPrintBuffer(buffer, len, withSpace)
#define emberAfDebugPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEBUG)


// Printing macros for Application
// Prints messages for application part
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APP)


#define emberAfAppDebug(...) UTIL_LOG_DBG(__VA_ARGS__)

#define emberAfAppPrint(...) emberAfPrint(EMBER_AF_PRINT_APP, __VA_ARGS__)
#define emberAfAppPrintln(...) emberAfPrintln(EMBER_AF_PRINT_APP,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfAppFlush()
#define emberAfAppDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_APP) ) { x; }
#define emberAfAppPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_APP, (buffer), (len), (withSpace))
#define emberAfAppPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_APP, (buffer))
#else

#define emberAfAppDebug(...)

#define emberAfAppPrint(...)
#define emberAfAppPrintln(...)
#define emberAfAppFlush()
#define emberAfAppDebugExec(x)
#define emberAfAppPrintBuffer(buffer, len, withSpace)
#define emberAfAppPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APP)


// Printing macros for Security
// Prints messages related to security
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SECURITY)
#define emberAfSecurityPrint(...) emberAfPrint(EMBER_AF_PRINT_SECURITY, __VA_ARGS__)
#define emberAfSecurityPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SECURITY,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfSecurityFlush()
#define emberAfSecurityDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_SECURITY) ) { x; }
#define emberAfSecurityPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_SECURITY, (buffer), (len), (withSpace))
#define emberAfSecurityPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SECURITY, (buffer))
#else
#define emberAfSecurityPrint(...)
#define emberAfSecurityPrintln(...)
#define emberAfSecurityFlush()
#define emberAfSecurityDebugExec(x)
#define emberAfSecurityPrintBuffer(buffer, len, withSpace)
#define emberAfSecurityPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SECURITY)


// Printing macros for Attributes
// Prints messages related to attributes
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ATTRIBUTES)
#define emberAfAttributesPrint(...) emberAfPrint(EMBER_AF_PRINT_ATTRIBUTES, __VA_ARGS__)
#define emberAfAttributesPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ATTRIBUTES,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfAttributesFlush()
#define emberAfAttributesDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_ATTRIBUTES) ) { x; }
#define emberAfAttributesPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_ATTRIBUTES, (buffer), (len), (withSpace))
#define emberAfAttributesPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ATTRIBUTES, (buffer))
#else
#define emberAfAttributesPrint(...)
#define emberAfAttributesPrintln(...)
#define emberAfAttributesFlush()
#define emberAfAttributesDebugExec(x)
#define emberAfAttributesPrintBuffer(buffer, len, withSpace)
#define emberAfAttributesPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ATTRIBUTES)


// Printing macros for Reporting
// Prints messages related to reporting
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_REPORTING)
#define emberAfReportingPrint(...) emberAfPrint(EMBER_AF_PRINT_REPORTING, __VA_ARGS__)
#define emberAfReportingPrintln(...) emberAfPrintln(EMBER_AF_PRINT_REPORTING,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfReportingFlush()
#define emberAfReportingDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_REPORTING) ) { x; }
#define emberAfReportingPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_REPORTING, (buffer), (len), (withSpace))
#define emberAfReportingPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_REPORTING, (buffer))
#else
#define emberAfReportingPrint(...)
#define emberAfReportingPrintln(...)
#define emberAfReportingFlush()
#define emberAfReportingDebugExec(x)
#define emberAfReportingPrintBuffer(buffer, len, withSpace)
#define emberAfReportingPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_REPORTING)


// Printing macros for Service discovery
// Prints messages related to service discovery
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SERVICE_DISCOVERY)
#define emberAfServiceDiscoveryPrint(...) emberAfPrint(EMBER_AF_PRINT_SERVICE_DISCOVERY, __VA_ARGS__)
#define emberAfServiceDiscoveryPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SERVICE_DISCOVERY,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfServiceDiscoveryFlush()
#define emberAfServiceDiscoveryDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_SERVICE_DISCOVERY) ) { x; }
#define emberAfServiceDiscoveryPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_SERVICE_DISCOVERY, (buffer), (len), (withSpace))
#define emberAfServiceDiscoveryPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SERVICE_DISCOVERY, (buffer))
#else
#define emberAfServiceDiscoveryPrint(...)
#define emberAfServiceDiscoveryPrintln(...)
#define emberAfServiceDiscoveryFlush()
#define emberAfServiceDiscoveryDebugExec(x)
#define emberAfServiceDiscoveryPrintBuffer(buffer, len, withSpace)
#define emberAfServiceDiscoveryPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SERVICE_DISCOVERY)


// Printing macros for Registration
// Prints messages related to registration
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_REGISTRATION)
#define emberAfRegistrationPrint(...) emberAfPrint(EMBER_AF_PRINT_REGISTRATION, __VA_ARGS__)
#define emberAfRegistrationPrintln(...) emberAfPrintln(EMBER_AF_PRINT_REGISTRATION,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfRegistrationFlush()
#define emberAfRegistrationDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_REGISTRATION) ) { x; }
#define emberAfRegistrationPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_REGISTRATION, (buffer), (len), (withSpace))
#define emberAfRegistrationPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_REGISTRATION, (buffer))
#else
#define emberAfRegistrationPrint(...)
#define emberAfRegistrationPrintln(...)
#define emberAfRegistrationFlush()
#define emberAfRegistrationDebugExec(x)
#define emberAfRegistrationPrintBuffer(buffer, len, withSpace)
#define emberAfRegistrationPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_REGISTRATION)


// Printing macros for ZDO (ZigBee Device Object)
// Prints messages related to ZDO functionality
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ZDO)
#define emberAfZdoPrint(...) emberAfPrint(EMBER_AF_PRINT_ZDO, __VA_ARGS__)
#define emberAfZdoPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ZDO,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfZdoFlush()
#define emberAfZdoDebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_ZDO) ) { x; }
#define emberAfZdoPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_ZDO, (buffer), (len), (withSpace))
#define emberAfZdoPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ZDO, (buffer))
#else
#define emberAfZdoPrint(...)
#define emberAfZdoPrintln(...)
#define emberAfZdoFlush()
#define emberAfZdoDebugExec(x)
#define emberAfZdoPrintBuffer(buffer, len, withSpace)
#define emberAfZdoPrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ZDO)


// Printing macros for Custom messages (1)
// Messages that can be used by the end developer
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CUSTOM1)
#define emberAfCustom1Print(...) emberAfPrint(EMBER_AF_PRINT_CUSTOM1, __VA_ARGS__)
#define emberAfCustom1Println(...) emberAfPrintln(EMBER_AF_PRINT_CUSTOM1,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfCustom1Flush()
#define emberAfCustom1DebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_CUSTOM1) ) { x; }
#define emberAfCustom1PrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_CUSTOM1, (buffer), (len), (withSpace))
#define emberAfCustom1PrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_CUSTOM1, (buffer))
#else
#define emberAfCustom1Print(...)
#define emberAfCustom1Println(...)
#define emberAfCustom1Flush()
#define emberAfCustom1DebugExec(x)
#define emberAfCustom1PrintBuffer(buffer, len, withSpace)
#define emberAfCustom1PrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CUSTOM1)


// Printing macros for Custom messages (2)
// Messages that can be used by the end developer
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CUSTOM2)
#define emberAfCustom2Print(...) emberAfPrint(EMBER_AF_PRINT_CUSTOM2, __VA_ARGS__)
#define emberAfCustom2Println(...) emberAfPrintln(EMBER_AF_PRINT_CUSTOM2,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfCustom2Flush()
#define emberAfCustom2DebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_CUSTOM2) ) { x; }
#define emberAfCustom2PrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_CUSTOM2, (buffer), (len), (withSpace))
#define emberAfCustom2PrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_CUSTOM2, (buffer))
#else
#define emberAfCustom2Print(...)
#define emberAfCustom2Println(...)
#define emberAfCustom2Flush()
#define emberAfCustom2DebugExec(x)
#define emberAfCustom2PrintBuffer(buffer, len, withSpace)
#define emberAfCustom2PrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CUSTOM2)


// Printing macros for Custom messages (3)
// Messages that can be used by the end developer
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CUSTOM3)
#define emberAfCustom3Print(...) emberAfPrint(EMBER_AF_PRINT_CUSTOM3, __VA_ARGS__)
#define emberAfCustom3Println(...) emberAfPrintln(EMBER_AF_PRINT_CUSTOM3,  __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfCustom3Flush()
#define emberAfCustom3DebugExec(x) if ( emberAfPrintEnabled(EMBER_AF_PRINT_CUSTOM3) ) { x; }
#define emberAfCustom3PrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_CUSTOM3, (buffer), (len), (withSpace))
#define emberAfCustom3PrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_CUSTOM3, (buffer))
#else
#define emberAfCustom3Print(...)
#define emberAfCustom3Println(...)
#define emberAfCustom3Flush()
#define emberAfCustom3DebugExec(x)
#define emberAfCustom3PrintBuffer(buffer, len, withSpace)
#define emberAfCustom3PrintString(buffer)
#endif //defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CUSTOM3)


#endif // SILABS_EMBER_AF_DEBUG_PRINTING
