/* This file is autogenerated by tracetool, do not edit. */

#ifndef TRACE_HW_INPUT_GENERATED_TRACERS_H
#define TRACE_HW_INPUT_GENERATED_TRACERS_H

#include "trace/control.h"

extern TraceEvent _TRACE_ADB_DEVICE_KBD_NO_KEY_EVENT;
extern TraceEvent _TRACE_ADB_DEVICE_KBD_WRITEREG_EVENT;
extern TraceEvent _TRACE_ADB_DEVICE_KBD_READREG_EVENT;
extern TraceEvent _TRACE_ADB_DEVICE_KBD_REQUEST_CHANGE_ADDR_EVENT;
extern TraceEvent _TRACE_ADB_DEVICE_KBD_REQUEST_CHANGE_ADDR_AND_HANDLER_EVENT;
extern TraceEvent _TRACE_ADB_DEVICE_MOUSE_FLUSH_EVENT;
extern TraceEvent _TRACE_ADB_DEVICE_MOUSE_WRITEREG_EVENT;
extern TraceEvent _TRACE_ADB_DEVICE_MOUSE_READREG_EVENT;
extern TraceEvent _TRACE_ADB_DEVICE_MOUSE_REQUEST_CHANGE_ADDR_EVENT;
extern TraceEvent _TRACE_ADB_DEVICE_MOUSE_REQUEST_CHANGE_ADDR_AND_HANDLER_EVENT;
extern TraceEvent _TRACE_ADB_BUS_REQUEST_EVENT;
extern TraceEvent _TRACE_ADB_BUS_REQUEST_DONE_EVENT;
extern TraceEvent _TRACE_ADB_BUS_AUTOPOLL_BLOCK_EVENT;
extern TraceEvent _TRACE_ADB_BUS_AUTOPOLL_CB_EVENT;
extern TraceEvent _TRACE_ADB_BUS_AUTOPOLL_CB_DONE_EVENT;
extern TraceEvent _TRACE_PCKBD_KBD_READ_DATA_EVENT;
extern TraceEvent _TRACE_PCKBD_KBD_READ_STATUS_EVENT;
extern TraceEvent _TRACE_PCKBD_OUTPORT_WRITE_EVENT;
extern TraceEvent _TRACE_PCKBD_KBD_WRITE_COMMAND_EVENT;
extern TraceEvent _TRACE_PCKBD_KBD_WRITE_DATA_EVENT;
extern TraceEvent _TRACE_PS2_PUT_KEYCODE_EVENT;
extern TraceEvent _TRACE_PS2_KEYBOARD_EVENT_EVENT;
extern TraceEvent _TRACE_PS2_READ_DATA_EVENT;
extern TraceEvent _TRACE_PS2_SET_LEDSTATE_EVENT;
extern TraceEvent _TRACE_PS2_RESET_KEYBOARD_EVENT;
extern TraceEvent _TRACE_PS2_WRITE_KEYBOARD_EVENT;
extern TraceEvent _TRACE_PS2_KEYBOARD_SET_TRANSLATION_EVENT;
extern TraceEvent _TRACE_PS2_MOUSE_SEND_PACKET_EVENT;
extern TraceEvent _TRACE_PS2_MOUSE_FAKE_EVENT_EVENT;
extern TraceEvent _TRACE_PS2_WRITE_MOUSE_EVENT;
extern TraceEvent _TRACE_PS2_KBD_RESET_EVENT;
extern TraceEvent _TRACE_PS2_MOUSE_RESET_EVENT;
extern TraceEvent _TRACE_HID_KBD_QUEUE_FULL_EVENT;
extern TraceEvent _TRACE_HID_KBD_QUEUE_EMPTY_EVENT;
extern TraceEvent _TRACE_TSC2005_SENSE_EVENT;
extern TraceEvent _TRACE_VIRTIO_INPUT_QUEUE_FULL_EVENT;
extern TraceEvent _TRACE_LASIPS2_REG_READ_EVENT;
extern TraceEvent _TRACE_LASIPS2_REG_WRITE_EVENT;
extern TraceEvent _TRACE_LASIPS2_INTR_EVENT;
extern uint16_t _TRACE_ADB_DEVICE_KBD_NO_KEY_DSTATE;
extern uint16_t _TRACE_ADB_DEVICE_KBD_WRITEREG_DSTATE;
extern uint16_t _TRACE_ADB_DEVICE_KBD_READREG_DSTATE;
extern uint16_t _TRACE_ADB_DEVICE_KBD_REQUEST_CHANGE_ADDR_DSTATE;
extern uint16_t _TRACE_ADB_DEVICE_KBD_REQUEST_CHANGE_ADDR_AND_HANDLER_DSTATE;
extern uint16_t _TRACE_ADB_DEVICE_MOUSE_FLUSH_DSTATE;
extern uint16_t _TRACE_ADB_DEVICE_MOUSE_WRITEREG_DSTATE;
extern uint16_t _TRACE_ADB_DEVICE_MOUSE_READREG_DSTATE;
extern uint16_t _TRACE_ADB_DEVICE_MOUSE_REQUEST_CHANGE_ADDR_DSTATE;
extern uint16_t _TRACE_ADB_DEVICE_MOUSE_REQUEST_CHANGE_ADDR_AND_HANDLER_DSTATE;
extern uint16_t _TRACE_ADB_BUS_REQUEST_DSTATE;
extern uint16_t _TRACE_ADB_BUS_REQUEST_DONE_DSTATE;
extern uint16_t _TRACE_ADB_BUS_AUTOPOLL_BLOCK_DSTATE;
extern uint16_t _TRACE_ADB_BUS_AUTOPOLL_CB_DSTATE;
extern uint16_t _TRACE_ADB_BUS_AUTOPOLL_CB_DONE_DSTATE;
extern uint16_t _TRACE_PCKBD_KBD_READ_DATA_DSTATE;
extern uint16_t _TRACE_PCKBD_KBD_READ_STATUS_DSTATE;
extern uint16_t _TRACE_PCKBD_OUTPORT_WRITE_DSTATE;
extern uint16_t _TRACE_PCKBD_KBD_WRITE_COMMAND_DSTATE;
extern uint16_t _TRACE_PCKBD_KBD_WRITE_DATA_DSTATE;
extern uint16_t _TRACE_PS2_PUT_KEYCODE_DSTATE;
extern uint16_t _TRACE_PS2_KEYBOARD_EVENT_DSTATE;
extern uint16_t _TRACE_PS2_READ_DATA_DSTATE;
extern uint16_t _TRACE_PS2_SET_LEDSTATE_DSTATE;
extern uint16_t _TRACE_PS2_RESET_KEYBOARD_DSTATE;
extern uint16_t _TRACE_PS2_WRITE_KEYBOARD_DSTATE;
extern uint16_t _TRACE_PS2_KEYBOARD_SET_TRANSLATION_DSTATE;
extern uint16_t _TRACE_PS2_MOUSE_SEND_PACKET_DSTATE;
extern uint16_t _TRACE_PS2_MOUSE_FAKE_EVENT_DSTATE;
extern uint16_t _TRACE_PS2_WRITE_MOUSE_DSTATE;
extern uint16_t _TRACE_PS2_KBD_RESET_DSTATE;
extern uint16_t _TRACE_PS2_MOUSE_RESET_DSTATE;
extern uint16_t _TRACE_HID_KBD_QUEUE_FULL_DSTATE;
extern uint16_t _TRACE_HID_KBD_QUEUE_EMPTY_DSTATE;
extern uint16_t _TRACE_TSC2005_SENSE_DSTATE;
extern uint16_t _TRACE_VIRTIO_INPUT_QUEUE_FULL_DSTATE;
extern uint16_t _TRACE_LASIPS2_REG_READ_DSTATE;
extern uint16_t _TRACE_LASIPS2_REG_WRITE_DSTATE;
extern uint16_t _TRACE_LASIPS2_INTR_DSTATE;
#define TRACE_ADB_DEVICE_KBD_NO_KEY_ENABLED 1
#define TRACE_ADB_DEVICE_KBD_WRITEREG_ENABLED 1
#define TRACE_ADB_DEVICE_KBD_READREG_ENABLED 1
#define TRACE_ADB_DEVICE_KBD_REQUEST_CHANGE_ADDR_ENABLED 1
#define TRACE_ADB_DEVICE_KBD_REQUEST_CHANGE_ADDR_AND_HANDLER_ENABLED 1
#define TRACE_ADB_DEVICE_MOUSE_FLUSH_ENABLED 1
#define TRACE_ADB_DEVICE_MOUSE_WRITEREG_ENABLED 1
#define TRACE_ADB_DEVICE_MOUSE_READREG_ENABLED 1
#define TRACE_ADB_DEVICE_MOUSE_REQUEST_CHANGE_ADDR_ENABLED 1
#define TRACE_ADB_DEVICE_MOUSE_REQUEST_CHANGE_ADDR_AND_HANDLER_ENABLED 1
#define TRACE_ADB_BUS_REQUEST_ENABLED 1
#define TRACE_ADB_BUS_REQUEST_DONE_ENABLED 1
#define TRACE_ADB_BUS_AUTOPOLL_BLOCK_ENABLED 1
#define TRACE_ADB_BUS_AUTOPOLL_CB_ENABLED 1
#define TRACE_ADB_BUS_AUTOPOLL_CB_DONE_ENABLED 1
#define TRACE_PCKBD_KBD_READ_DATA_ENABLED 1
#define TRACE_PCKBD_KBD_READ_STATUS_ENABLED 1
#define TRACE_PCKBD_OUTPORT_WRITE_ENABLED 1
#define TRACE_PCKBD_KBD_WRITE_COMMAND_ENABLED 1
#define TRACE_PCKBD_KBD_WRITE_DATA_ENABLED 1
#define TRACE_PS2_PUT_KEYCODE_ENABLED 1
#define TRACE_PS2_KEYBOARD_EVENT_ENABLED 1
#define TRACE_PS2_READ_DATA_ENABLED 1
#define TRACE_PS2_SET_LEDSTATE_ENABLED 1
#define TRACE_PS2_RESET_KEYBOARD_ENABLED 1
#define TRACE_PS2_WRITE_KEYBOARD_ENABLED 1
#define TRACE_PS2_KEYBOARD_SET_TRANSLATION_ENABLED 1
#define TRACE_PS2_MOUSE_SEND_PACKET_ENABLED 1
#define TRACE_PS2_MOUSE_FAKE_EVENT_ENABLED 1
#define TRACE_PS2_WRITE_MOUSE_ENABLED 1
#define TRACE_PS2_KBD_RESET_ENABLED 1
#define TRACE_PS2_MOUSE_RESET_ENABLED 1
#define TRACE_HID_KBD_QUEUE_FULL_ENABLED 1
#define TRACE_HID_KBD_QUEUE_EMPTY_ENABLED 1
#define TRACE_TSC2005_SENSE_ENABLED 1
#define TRACE_VIRTIO_INPUT_QUEUE_FULL_ENABLED 1
#define TRACE_LASIPS2_REG_READ_ENABLED 1
#define TRACE_LASIPS2_REG_WRITE_ENABLED 1
#define TRACE_LASIPS2_INTR_ENABLED 1
#include "qemu/log-for-trace.h"
#include "qemu/error-report.h"


#define TRACE_ADB_DEVICE_KBD_NO_KEY_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_ADB_DEVICE_KBD_NO_KEY) || \
    false)

static inline void _nocheck__trace_adb_device_kbd_no_key(void)
{
    if (trace_event_get_state(TRACE_ADB_DEVICE_KBD_NO_KEY) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 4 "../git/hw/input/trace-events"
            qemu_log("%d@%zu.%06zu:adb_device_kbd_no_key " "Ignoring NO_KEY" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 145 "trace/trace-hw_input.h"
        } else {
#line 4 "../git/hw/input/trace-events"
            qemu_log("adb_device_kbd_no_key " "Ignoring NO_KEY" "\n");
#line 149 "trace/trace-hw_input.h"
        }
    }
}

static inline void trace_adb_device_kbd_no_key(void)
{
    if (true) {
        _nocheck__trace_adb_device_kbd_no_key();
    }
}

#define TRACE_ADB_DEVICE_KBD_WRITEREG_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_ADB_DEVICE_KBD_WRITEREG) || \
    false)

static inline void _nocheck__trace_adb_device_kbd_writereg(int reg, uint8_t val)
{
    if (trace_event_get_state(TRACE_ADB_DEVICE_KBD_WRITEREG) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 5 "../git/hw/input/trace-events"
            qemu_log("%d@%zu.%06zu:adb_device_kbd_writereg " "reg %d val 0x%2.2x" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , reg, val);
#line 176 "trace/trace-hw_input.h"
        } else {
#line 5 "../git/hw/input/trace-events"
            qemu_log("adb_device_kbd_writereg " "reg %d val 0x%2.2x" "\n", reg, val);
#line 180 "trace/trace-hw_input.h"
        }
    }
}

static inline void trace_adb_device_kbd_writereg(int reg, uint8_t val)
{
    if (true) {
        _nocheck__trace_adb_device_kbd_writereg(reg, val);
    }
}

#define TRACE_ADB_DEVICE_KBD_READREG_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_ADB_DEVICE_KBD_READREG) || \
    false)

static inline void _nocheck__trace_adb_device_kbd_readreg(int reg, uint8_t val0, uint8_t val1)
{
    if (trace_event_get_state(TRACE_ADB_DEVICE_KBD_READREG) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 6 "../git/hw/input/trace-events"
            qemu_log("%d@%zu.%06zu:adb_device_kbd_readreg " "reg %d obuf[0] 0x%2.2x obuf[1] 0x%2.2x" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , reg, val0, val1);
#line 207 "trace/trace-hw_input.h"
        } else {
#line 6 "../git/hw/input/trace-events"
            qemu_log("adb_device_kbd_readreg " "reg %d obuf[0] 0x%2.2x obuf[1] 0x%2.2x" "\n", reg, val0, val1);
#line 211 "trace/trace-hw_input.h"
        }
    }
}

static inline void trace_adb_device_kbd_readreg(int reg, uint8_t val0, uint8_t val1)
{
    if (true) {
        _nocheck__trace_adb_device_kbd_readreg(reg, val0, val1);
    }
}

#define TRACE_ADB_DEVICE_KBD_REQUEST_CHANGE_ADDR_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_ADB_DEVICE_KBD_REQUEST_CHANGE_ADDR) || \
    false)

static inline void _nocheck__trace_adb_device_kbd_request_change_addr(int devaddr)
{
    if (trace_event_get_state(TRACE_ADB_DEVICE_KBD_REQUEST_CHANGE_ADDR) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 7 "../git/hw/input/trace-events"
            qemu_log("%d@%zu.%06zu:adb_device_kbd_request_change_addr " "change addr to 0x%x" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , devaddr);
#line 238 "trace/trace-hw_input.h"
        } else {
#line 7 "../git/hw/input/trace-events"
            qemu_log("adb_device_kbd_request_change_addr " "change addr to 0x%x" "\n", devaddr);
#line 242 "trace/trace-hw_input.h"
        }
    }
}

static inline void trace_adb_device_kbd_request_change_addr(int devaddr)
{
    if (true) {
        _nocheck__trace_adb_device_kbd_request_change_addr(devaddr);
    }
}

#define TRACE_ADB_DEVICE_KBD_REQUEST_CHANGE_ADDR_AND_HANDLER_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_ADB_DEVICE_KBD_REQUEST_CHANGE_ADDR_AND_HANDLER) || \
    false)

static inline void _nocheck__trace_adb_device_kbd_request_change_addr_and_handler(int devaddr, int handler)
{
    if (trace_event_get_state(TRACE_ADB_DEVICE_KBD_REQUEST_CHANGE_ADDR_AND_HANDLER) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 8 "../git/hw/input/trace-events"
            qemu_log("%d@%zu.%06zu:adb_device_kbd_request_change_addr_and_handler " "change addr and handler to 0x%x, 0x%x" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , devaddr, handler);
#line 269 "trace/trace-hw_input.h"
        } else {
#line 8 "../git/hw/input/trace-events"
            qemu_log("adb_device_kbd_request_change_addr_and_handler " "change addr and handler to 0x%x, 0x%x" "\n", devaddr, handler);
#line 273 "trace/trace-hw_input.h"
        }
    }
}

static inline void trace_adb_device_kbd_request_change_addr_and_handler(int devaddr, int handler)
{
    if (true) {
        _nocheck__trace_adb_device_kbd_request_change_addr_and_handler(devaddr, handler);
    }
}

#define TRACE_ADB_DEVICE_MOUSE_FLUSH_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_ADB_DEVICE_MOUSE_FLUSH) || \
    false)

static inline void _nocheck__trace_adb_device_mouse_flush(void)
{
    if (trace_event_get_state(TRACE_ADB_DEVICE_MOUSE_FLUSH) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 11 "../git/hw/input/trace-events"
            qemu_log("%d@%zu.%06zu:adb_device_mouse_flush " "flush" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 300 "trace/trace-hw_input.h"
        } else {
#line 11 "../git/hw/input/trace-events"
            qemu_log("adb_device_mouse_flush " "flush" "\n");
#line 304 "trace/trace-hw_input.h"
        }
    }
}

static inline void trace_adb_device_mouse_flush(void)
{
    if (true) {
        _nocheck__trace_adb_device_mouse_flush();
    }
}

#define TRACE_ADB_DEVICE_MOUSE_WRITEREG_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_ADB_DEVICE_MOUSE_WRITEREG) || \
    false)

static inline void _nocheck__trace_adb_device_mouse_writereg(int reg, uint8_t val)
{
    if (trace_event_get_state(TRACE_ADB_DEVICE_MOUSE_WRITEREG) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 12 "../git/hw/input/trace-events"
            qemu_log("%d@%zu.%06zu:adb_device_mouse_writereg " "reg %d val 0x%2.2x" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , reg, val);
#line 331 "trace/trace-hw_input.h"
        } else {
#line 12 "../git/hw/input/trace-events"
            qemu_log("adb_device_mouse_writereg " "reg %d val 0x%2.2x" "\n", reg, val);
#line 335 "trace/trace-hw_input.h"
        }
    }
}

static inline void trace_adb_device_mouse_writereg(int reg, uint8_t val)
{
    if (true) {
        _nocheck__trace_adb_device_mouse_writereg(reg, val);
    }
}

#define TRACE_ADB_DEVICE_MOUSE_READREG_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_ADB_DEVICE_MOUSE_READREG) || \
    false)

static inline void _nocheck__trace_adb_device_mouse_readreg(int reg, uint8_t val0, uint8_t val1)
{
    if (trace_event_get_state(TRACE_ADB_DEVICE_MOUSE_READREG) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 13 "../git/hw/input/trace-events"
            qemu_log("%d@%zu.%06zu:adb_device_mouse_readreg " "reg %d obuf[0] 0x%2.2x obuf[1] 0x%2.2x" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , reg, val0, val1);
#line 362 "trace/trace-hw_input.h"
        } else {
#line 13 "../git/hw/input/trace-events"
            qemu_log("adb_device_mouse_readreg " "reg %d obuf[0] 0x%2.2x obuf[1] 0x%2.2x" "\n", reg, val0, val1);
#line 366 "trace/trace-hw_input.h"
        }
    }
}

static inline void trace_adb_device_mouse_readreg(int reg, uint8_t val0, uint8_t val1)
{
    if (true) {
        _nocheck__trace_adb_device_mouse_readreg(reg, val0, val1);
    }
}

#define TRACE_ADB_DEVICE_MOUSE_REQUEST_CHANGE_ADDR_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_ADB_DEVICE_MOUSE_REQUEST_CHANGE_ADDR) || \
    false)

static inline void _nocheck__trace_adb_device_mouse_request_change_addr(int devaddr)
{
    if (trace_event_get_state(TRACE_ADB_DEVICE_MOUSE_REQUEST_CHANGE_ADDR) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 14 "../git/hw/input/trace-events"
            qemu_log("%d@%zu.%06zu:adb_device_mouse_request_change_addr " "change addr to 0x%x" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , devaddr);
#line 393 "trace/trace-hw_input.h"
        } else {
#line 14 "../git/hw/input/trace-events"
            qemu_log("adb_device_mouse_request_change_addr " "change addr to 0x%x" "\n", devaddr);
#line 397 "trace/trace-hw_input.h"
        }
    }
}

static inline void trace_adb_device_mouse_request_change_addr(int devaddr)
{
    if (true) {
        _nocheck__trace_adb_device_mouse_request_change_addr(devaddr);
    }
}

#define TRACE_ADB_DEVICE_MOUSE_REQUEST_CHANGE_ADDR_AND_HANDLER_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_ADB_DEVICE_MOUSE_REQUEST_CHANGE_ADDR_AND_HANDLER) || \
    false)

static inline void _nocheck__trace_adb_device_mouse_request_change_addr_and_handler(int devaddr, int handler)
{
    if (trace_event_get_state(TRACE_ADB_DEVICE_MOUSE_REQUEST_CHANGE_ADDR_AND_HANDLER) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 15 "../git/hw/input/trace-events"
            qemu_log("%d@%zu.%06zu:adb_device_mouse_request_change_addr_and_handler " "change addr and handler to 0x%x, 0x%x" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , devaddr, handler);
#line 424 "trace/trace-hw_input.h"
        } else {
#line 15 "../git/hw/input/trace-events"
            qemu_log("adb_device_mouse_request_change_addr_and_handler " "change addr and handler to 0x%x, 0x%x" "\n", devaddr, handler);
#line 428 "trace/trace-hw_input.h"
        }
    }
}

static inline void trace_adb_device_mouse_request_change_addr_and_handler(int devaddr, int handler)
{
    if (true) {
        _nocheck__trace_adb_device_mouse_request_change_addr_and_handler(devaddr, handler);
    }
}

#define TRACE_ADB_BUS_REQUEST_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_ADB_BUS_REQUEST) || \
    false)

static inline void _nocheck__trace_adb_bus_request(uint8_t addr, const char * cmd, int size)
{
    if (trace_event_get_state(TRACE_ADB_BUS_REQUEST) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 18 "../git/hw/input/trace-events"
            qemu_log("%d@%zu.%06zu:adb_bus_request " "device 0x%x %s cmdsize=%d" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , addr, cmd, size);
#line 455 "trace/trace-hw_input.h"
        } else {
#line 18 "../git/hw/input/trace-events"
            qemu_log("adb_bus_request " "device 0x%x %s cmdsize=%d" "\n", addr, cmd, size);
#line 459 "trace/trace-hw_input.h"
        }
    }
}

static inline void trace_adb_bus_request(uint8_t addr, const char * cmd, int size)
{
    if (true) {
        _nocheck__trace_adb_bus_request(addr, cmd, size);
    }
}

#define TRACE_ADB_BUS_REQUEST_DONE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_ADB_BUS_REQUEST_DONE) || \
    false)

static inline void _nocheck__trace_adb_bus_request_done(uint8_t addr, const char * cmd, int size)
{
    if (trace_event_get_state(TRACE_ADB_BUS_REQUEST_DONE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 19 "../git/hw/input/trace-events"
            qemu_log("%d@%zu.%06zu:adb_bus_request_done " "device 0x%x %s replysize=%d" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , addr, cmd, size);
#line 486 "trace/trace-hw_input.h"
        } else {
#line 19 "../git/hw/input/trace-events"
            qemu_log("adb_bus_request_done " "device 0x%x %s replysize=%d" "\n", addr, cmd, size);
#line 490 "trace/trace-hw_input.h"
        }
    }
}

static inline void trace_adb_bus_request_done(uint8_t addr, const char * cmd, int size)
{
    if (true) {
        _nocheck__trace_adb_bus_request_done(addr, cmd, size);
    }
}

#define TRACE_ADB_BUS_AUTOPOLL_BLOCK_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_ADB_BUS_AUTOPOLL_BLOCK) || \
    false)

static inline void _nocheck__trace_adb_bus_autopoll_block(bool blocked)
{
    if (trace_event_get_state(TRACE_ADB_BUS_AUTOPOLL_BLOCK) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 20 "../git/hw/input/trace-events"
            qemu_log("%d@%zu.%06zu:adb_bus_autopoll_block " "blocked: %d" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , blocked);
#line 517 "trace/trace-hw_input.h"
        } else {
#line 20 "../git/hw/input/trace-events"
            qemu_log("adb_bus_autopoll_block " "blocked: %d" "\n", blocked);
#line 521 "trace/trace-hw_input.h"
        }
    }
}

static inline void trace_adb_bus_autopoll_block(bool blocked)
{
    if (true) {
        _nocheck__trace_adb_bus_autopoll_block(blocked);
    }
}

#define TRACE_ADB_BUS_AUTOPOLL_CB_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_ADB_BUS_AUTOPOLL_CB) || \
    false)

static inline void _nocheck__trace_adb_bus_autopoll_cb(uint16_t mask)
{
    if (trace_event_get_state(TRACE_ADB_BUS_AUTOPOLL_CB) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 21 "../git/hw/input/trace-events"
            qemu_log("%d@%zu.%06zu:adb_bus_autopoll_cb " "executing autopoll_cb with autopoll mask 0x%x" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , mask);
#line 548 "trace/trace-hw_input.h"
        } else {
#line 21 "../git/hw/input/trace-events"
            qemu_log("adb_bus_autopoll_cb " "executing autopoll_cb with autopoll mask 0x%x" "\n", mask);
#line 552 "trace/trace-hw_input.h"
        }
    }
}

static inline void trace_adb_bus_autopoll_cb(uint16_t mask)
{
    if (true) {
        _nocheck__trace_adb_bus_autopoll_cb(mask);
    }
}

#define TRACE_ADB_BUS_AUTOPOLL_CB_DONE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_ADB_BUS_AUTOPOLL_CB_DONE) || \
    false)

static inline void _nocheck__trace_adb_bus_autopoll_cb_done(uint16_t mask)
{
    if (trace_event_get_state(TRACE_ADB_BUS_AUTOPOLL_CB_DONE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 22 "../git/hw/input/trace-events"
            qemu_log("%d@%zu.%06zu:adb_bus_autopoll_cb_done " "done executing autopoll_cb with autopoll mask 0x%x" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , mask);
#line 579 "trace/trace-hw_input.h"
        } else {
#line 22 "../git/hw/input/trace-events"
            qemu_log("adb_bus_autopoll_cb_done " "done executing autopoll_cb with autopoll mask 0x%x" "\n", mask);
#line 583 "trace/trace-hw_input.h"
        }
    }
}

static inline void trace_adb_bus_autopoll_cb_done(uint16_t mask)
{
    if (true) {
        _nocheck__trace_adb_bus_autopoll_cb_done(mask);
    }
}

#define TRACE_PCKBD_KBD_READ_DATA_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PCKBD_KBD_READ_DATA) || \
    false)

static inline void _nocheck__trace_pckbd_kbd_read_data(uint32_t val)
{
    if (trace_event_get_state(TRACE_PCKBD_KBD_READ_DATA) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 25 "../git/hw/input/trace-events"
            qemu_log("%d@%zu.%06zu:pckbd_kbd_read_data " "0x%02x" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , val);
#line 610 "trace/trace-hw_input.h"
        } else {
#line 25 "../git/hw/input/trace-events"
            qemu_log("pckbd_kbd_read_data " "0x%02x" "\n", val);
#line 614 "trace/trace-hw_input.h"
        }
    }
}

static inline void trace_pckbd_kbd_read_data(uint32_t val)
{
    if (true) {
        _nocheck__trace_pckbd_kbd_read_data(val);
    }
}

#define TRACE_PCKBD_KBD_READ_STATUS_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PCKBD_KBD_READ_STATUS) || \
    false)

static inline void _nocheck__trace_pckbd_kbd_read_status(int status)
{
    if (trace_event_get_state(TRACE_PCKBD_KBD_READ_STATUS) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 26 "../git/hw/input/trace-events"
            qemu_log("%d@%zu.%06zu:pckbd_kbd_read_status " "0x%02x" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , status);
#line 641 "trace/trace-hw_input.h"
        } else {
#line 26 "../git/hw/input/trace-events"
            qemu_log("pckbd_kbd_read_status " "0x%02x" "\n", status);
#line 645 "trace/trace-hw_input.h"
        }
    }
}

static inline void trace_pckbd_kbd_read_status(int status)
{
    if (true) {
        _nocheck__trace_pckbd_kbd_read_status(status);
    }
}

#define TRACE_PCKBD_OUTPORT_WRITE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PCKBD_OUTPORT_WRITE) || \
    false)

static inline void _nocheck__trace_pckbd_outport_write(uint32_t val)
{
    if (trace_event_get_state(TRACE_PCKBD_OUTPORT_WRITE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 27 "../git/hw/input/trace-events"
            qemu_log("%d@%zu.%06zu:pckbd_outport_write " "0x%02x" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , val);
#line 672 "trace/trace-hw_input.h"
        } else {
#line 27 "../git/hw/input/trace-events"
            qemu_log("pckbd_outport_write " "0x%02x" "\n", val);
#line 676 "trace/trace-hw_input.h"
        }
    }
}

static inline void trace_pckbd_outport_write(uint32_t val)
{
    if (true) {
        _nocheck__trace_pckbd_outport_write(val);
    }
}

#define TRACE_PCKBD_KBD_WRITE_COMMAND_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PCKBD_KBD_WRITE_COMMAND) || \
    false)

static inline void _nocheck__trace_pckbd_kbd_write_command(uint64_t val)
{
    if (trace_event_get_state(TRACE_PCKBD_KBD_WRITE_COMMAND) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 28 "../git/hw/input/trace-events"
            qemu_log("%d@%zu.%06zu:pckbd_kbd_write_command " "0x%02"PRIx64 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , val);
#line 703 "trace/trace-hw_input.h"
        } else {
#line 28 "../git/hw/input/trace-events"
            qemu_log("pckbd_kbd_write_command " "0x%02"PRIx64 "\n", val);
#line 707 "trace/trace-hw_input.h"
        }
    }
}

static inline void trace_pckbd_kbd_write_command(uint64_t val)
{
    if (true) {
        _nocheck__trace_pckbd_kbd_write_command(val);
    }
}

#define TRACE_PCKBD_KBD_WRITE_DATA_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PCKBD_KBD_WRITE_DATA) || \
    false)

static inline void _nocheck__trace_pckbd_kbd_write_data(uint64_t val)
{
    if (trace_event_get_state(TRACE_PCKBD_KBD_WRITE_DATA) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 29 "../git/hw/input/trace-events"
            qemu_log("%d@%zu.%06zu:pckbd_kbd_write_data " "0x%02"PRIx64 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , val);
#line 734 "trace/trace-hw_input.h"
        } else {
#line 29 "../git/hw/input/trace-events"
            qemu_log("pckbd_kbd_write_data " "0x%02"PRIx64 "\n", val);
#line 738 "trace/trace-hw_input.h"
        }
    }
}

static inline void trace_pckbd_kbd_write_data(uint64_t val)
{
    if (true) {
        _nocheck__trace_pckbd_kbd_write_data(val);
    }
}

#define TRACE_PS2_PUT_KEYCODE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PS2_PUT_KEYCODE) || \
    false)

static inline void _nocheck__trace_ps2_put_keycode(void * opaque, int keycode)
{
    if (trace_event_get_state(TRACE_PS2_PUT_KEYCODE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 32 "../git/hw/input/trace-events"
            qemu_log("%d@%zu.%06zu:ps2_put_keycode " "%p keycode 0x%02x" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , opaque, keycode);
#line 765 "trace/trace-hw_input.h"
        } else {
#line 32 "../git/hw/input/trace-events"
            qemu_log("ps2_put_keycode " "%p keycode 0x%02x" "\n", opaque, keycode);
#line 769 "trace/trace-hw_input.h"
        }
    }
}

static inline void trace_ps2_put_keycode(void * opaque, int keycode)
{
    if (true) {
        _nocheck__trace_ps2_put_keycode(opaque, keycode);
    }
}

#define TRACE_PS2_KEYBOARD_EVENT_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PS2_KEYBOARD_EVENT) || \
    false)

static inline void _nocheck__trace_ps2_keyboard_event(void * opaque, int qcode, int down, unsigned int modifier, unsigned int modifiers, int set, int xlate)
{
    if (trace_event_get_state(TRACE_PS2_KEYBOARD_EVENT) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 33 "../git/hw/input/trace-events"
            qemu_log("%d@%zu.%06zu:ps2_keyboard_event " "%p qcode %d down %d modifier 0x%x modifiers 0x%x set %d xlate %d" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , opaque, qcode, down, modifier, modifiers, set, xlate);
#line 796 "trace/trace-hw_input.h"
        } else {
#line 33 "../git/hw/input/trace-events"
            qemu_log("ps2_keyboard_event " "%p qcode %d down %d modifier 0x%x modifiers 0x%x set %d xlate %d" "\n", opaque, qcode, down, modifier, modifiers, set, xlate);
#line 800 "trace/trace-hw_input.h"
        }
    }
}

static inline void trace_ps2_keyboard_event(void * opaque, int qcode, int down, unsigned int modifier, unsigned int modifiers, int set, int xlate)
{
    if (true) {
        _nocheck__trace_ps2_keyboard_event(opaque, qcode, down, modifier, modifiers, set, xlate);
    }
}

#define TRACE_PS2_READ_DATA_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PS2_READ_DATA) || \
    false)

static inline void _nocheck__trace_ps2_read_data(void * opaque)
{
    if (trace_event_get_state(TRACE_PS2_READ_DATA) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 34 "../git/hw/input/trace-events"
            qemu_log("%d@%zu.%06zu:ps2_read_data " "%p" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , opaque);
#line 827 "trace/trace-hw_input.h"
        } else {
#line 34 "../git/hw/input/trace-events"
            qemu_log("ps2_read_data " "%p" "\n", opaque);
#line 831 "trace/trace-hw_input.h"
        }
    }
}

static inline void trace_ps2_read_data(void * opaque)
{
    if (true) {
        _nocheck__trace_ps2_read_data(opaque);
    }
}

#define TRACE_PS2_SET_LEDSTATE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PS2_SET_LEDSTATE) || \
    false)

static inline void _nocheck__trace_ps2_set_ledstate(void * s, int ledstate)
{
    if (trace_event_get_state(TRACE_PS2_SET_LEDSTATE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 35 "../git/hw/input/trace-events"
            qemu_log("%d@%zu.%06zu:ps2_set_ledstate " "%p ledstate %d" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , s, ledstate);
#line 858 "trace/trace-hw_input.h"
        } else {
#line 35 "../git/hw/input/trace-events"
            qemu_log("ps2_set_ledstate " "%p ledstate %d" "\n", s, ledstate);
#line 862 "trace/trace-hw_input.h"
        }
    }
}

static inline void trace_ps2_set_ledstate(void * s, int ledstate)
{
    if (true) {
        _nocheck__trace_ps2_set_ledstate(s, ledstate);
    }
}

#define TRACE_PS2_RESET_KEYBOARD_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PS2_RESET_KEYBOARD) || \
    false)

static inline void _nocheck__trace_ps2_reset_keyboard(void * s)
{
    if (trace_event_get_state(TRACE_PS2_RESET_KEYBOARD) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 36 "../git/hw/input/trace-events"
            qemu_log("%d@%zu.%06zu:ps2_reset_keyboard " "%p" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , s);
#line 889 "trace/trace-hw_input.h"
        } else {
#line 36 "../git/hw/input/trace-events"
            qemu_log("ps2_reset_keyboard " "%p" "\n", s);
#line 893 "trace/trace-hw_input.h"
        }
    }
}

static inline void trace_ps2_reset_keyboard(void * s)
{
    if (true) {
        _nocheck__trace_ps2_reset_keyboard(s);
    }
}

#define TRACE_PS2_WRITE_KEYBOARD_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PS2_WRITE_KEYBOARD) || \
    false)

static inline void _nocheck__trace_ps2_write_keyboard(void * opaque, int val)
{
    if (trace_event_get_state(TRACE_PS2_WRITE_KEYBOARD) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 37 "../git/hw/input/trace-events"
            qemu_log("%d@%zu.%06zu:ps2_write_keyboard " "%p val %d" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , opaque, val);
#line 920 "trace/trace-hw_input.h"
        } else {
#line 37 "../git/hw/input/trace-events"
            qemu_log("ps2_write_keyboard " "%p val %d" "\n", opaque, val);
#line 924 "trace/trace-hw_input.h"
        }
    }
}

static inline void trace_ps2_write_keyboard(void * opaque, int val)
{
    if (true) {
        _nocheck__trace_ps2_write_keyboard(opaque, val);
    }
}

#define TRACE_PS2_KEYBOARD_SET_TRANSLATION_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PS2_KEYBOARD_SET_TRANSLATION) || \
    false)

static inline void _nocheck__trace_ps2_keyboard_set_translation(void * opaque, int mode)
{
    if (trace_event_get_state(TRACE_PS2_KEYBOARD_SET_TRANSLATION) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 38 "../git/hw/input/trace-events"
            qemu_log("%d@%zu.%06zu:ps2_keyboard_set_translation " "%p mode %d" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , opaque, mode);
#line 951 "trace/trace-hw_input.h"
        } else {
#line 38 "../git/hw/input/trace-events"
            qemu_log("ps2_keyboard_set_translation " "%p mode %d" "\n", opaque, mode);
#line 955 "trace/trace-hw_input.h"
        }
    }
}

static inline void trace_ps2_keyboard_set_translation(void * opaque, int mode)
{
    if (true) {
        _nocheck__trace_ps2_keyboard_set_translation(opaque, mode);
    }
}

#define TRACE_PS2_MOUSE_SEND_PACKET_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PS2_MOUSE_SEND_PACKET) || \
    false)

static inline void _nocheck__trace_ps2_mouse_send_packet(void * s, int dx1, int dy1, int dz1, int b)
{
    if (trace_event_get_state(TRACE_PS2_MOUSE_SEND_PACKET) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 39 "../git/hw/input/trace-events"
            qemu_log("%d@%zu.%06zu:ps2_mouse_send_packet " "%p x %d y %d z %d bs 0x%x" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , s, dx1, dy1, dz1, b);
#line 982 "trace/trace-hw_input.h"
        } else {
#line 39 "../git/hw/input/trace-events"
            qemu_log("ps2_mouse_send_packet " "%p x %d y %d z %d bs 0x%x" "\n", s, dx1, dy1, dz1, b);
#line 986 "trace/trace-hw_input.h"
        }
    }
}

static inline void trace_ps2_mouse_send_packet(void * s, int dx1, int dy1, int dz1, int b)
{
    if (true) {
        _nocheck__trace_ps2_mouse_send_packet(s, dx1, dy1, dz1, b);
    }
}

#define TRACE_PS2_MOUSE_FAKE_EVENT_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PS2_MOUSE_FAKE_EVENT) || \
    false)

static inline void _nocheck__trace_ps2_mouse_fake_event(void * opaque)
{
    if (trace_event_get_state(TRACE_PS2_MOUSE_FAKE_EVENT) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 40 "../git/hw/input/trace-events"
            qemu_log("%d@%zu.%06zu:ps2_mouse_fake_event " "%p" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , opaque);
#line 1013 "trace/trace-hw_input.h"
        } else {
#line 40 "../git/hw/input/trace-events"
            qemu_log("ps2_mouse_fake_event " "%p" "\n", opaque);
#line 1017 "trace/trace-hw_input.h"
        }
    }
}

static inline void trace_ps2_mouse_fake_event(void * opaque)
{
    if (true) {
        _nocheck__trace_ps2_mouse_fake_event(opaque);
    }
}

#define TRACE_PS2_WRITE_MOUSE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PS2_WRITE_MOUSE) || \
    false)

static inline void _nocheck__trace_ps2_write_mouse(void * opaque, int val)
{
    if (trace_event_get_state(TRACE_PS2_WRITE_MOUSE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 41 "../git/hw/input/trace-events"
            qemu_log("%d@%zu.%06zu:ps2_write_mouse " "%p val %d" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , opaque, val);
#line 1044 "trace/trace-hw_input.h"
        } else {
#line 41 "../git/hw/input/trace-events"
            qemu_log("ps2_write_mouse " "%p val %d" "\n", opaque, val);
#line 1048 "trace/trace-hw_input.h"
        }
    }
}

static inline void trace_ps2_write_mouse(void * opaque, int val)
{
    if (true) {
        _nocheck__trace_ps2_write_mouse(opaque, val);
    }
}

#define TRACE_PS2_KBD_RESET_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PS2_KBD_RESET) || \
    false)

static inline void _nocheck__trace_ps2_kbd_reset(void * opaque)
{
    if (trace_event_get_state(TRACE_PS2_KBD_RESET) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 42 "../git/hw/input/trace-events"
            qemu_log("%d@%zu.%06zu:ps2_kbd_reset " "%p" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , opaque);
#line 1075 "trace/trace-hw_input.h"
        } else {
#line 42 "../git/hw/input/trace-events"
            qemu_log("ps2_kbd_reset " "%p" "\n", opaque);
#line 1079 "trace/trace-hw_input.h"
        }
    }
}

static inline void trace_ps2_kbd_reset(void * opaque)
{
    if (true) {
        _nocheck__trace_ps2_kbd_reset(opaque);
    }
}

#define TRACE_PS2_MOUSE_RESET_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_PS2_MOUSE_RESET) || \
    false)

static inline void _nocheck__trace_ps2_mouse_reset(void * opaque)
{
    if (trace_event_get_state(TRACE_PS2_MOUSE_RESET) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 43 "../git/hw/input/trace-events"
            qemu_log("%d@%zu.%06zu:ps2_mouse_reset " "%p" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , opaque);
#line 1106 "trace/trace-hw_input.h"
        } else {
#line 43 "../git/hw/input/trace-events"
            qemu_log("ps2_mouse_reset " "%p" "\n", opaque);
#line 1110 "trace/trace-hw_input.h"
        }
    }
}

static inline void trace_ps2_mouse_reset(void * opaque)
{
    if (true) {
        _nocheck__trace_ps2_mouse_reset(opaque);
    }
}

#define TRACE_HID_KBD_QUEUE_FULL_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_HID_KBD_QUEUE_FULL) || \
    false)

static inline void _nocheck__trace_hid_kbd_queue_full(void)
{
    if (trace_event_get_state(TRACE_HID_KBD_QUEUE_FULL) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 46 "../git/hw/input/trace-events"
            qemu_log("%d@%zu.%06zu:hid_kbd_queue_full " "queue full" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 1137 "trace/trace-hw_input.h"
        } else {
#line 46 "../git/hw/input/trace-events"
            qemu_log("hid_kbd_queue_full " "queue full" "\n");
#line 1141 "trace/trace-hw_input.h"
        }
    }
}

static inline void trace_hid_kbd_queue_full(void)
{
    if (true) {
        _nocheck__trace_hid_kbd_queue_full();
    }
}

#define TRACE_HID_KBD_QUEUE_EMPTY_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_HID_KBD_QUEUE_EMPTY) || \
    false)

static inline void _nocheck__trace_hid_kbd_queue_empty(void)
{
    if (trace_event_get_state(TRACE_HID_KBD_QUEUE_EMPTY) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 47 "../git/hw/input/trace-events"
            qemu_log("%d@%zu.%06zu:hid_kbd_queue_empty " "queue empty" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 1168 "trace/trace-hw_input.h"
        } else {
#line 47 "../git/hw/input/trace-events"
            qemu_log("hid_kbd_queue_empty " "queue empty" "\n");
#line 1172 "trace/trace-hw_input.h"
        }
    }
}

static inline void trace_hid_kbd_queue_empty(void)
{
    if (true) {
        _nocheck__trace_hid_kbd_queue_empty();
    }
}

#define TRACE_TSC2005_SENSE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_TSC2005_SENSE) || \
    false)

static inline void _nocheck__trace_tsc2005_sense(const char * state)
{
    if (trace_event_get_state(TRACE_TSC2005_SENSE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 50 "../git/hw/input/trace-events"
            qemu_log("%d@%zu.%06zu:tsc2005_sense " "touchscreen sense %s" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , state);
#line 1199 "trace/trace-hw_input.h"
        } else {
#line 50 "../git/hw/input/trace-events"
            qemu_log("tsc2005_sense " "touchscreen sense %s" "\n", state);
#line 1203 "trace/trace-hw_input.h"
        }
    }
}

static inline void trace_tsc2005_sense(const char * state)
{
    if (true) {
        _nocheck__trace_tsc2005_sense(state);
    }
}

#define TRACE_VIRTIO_INPUT_QUEUE_FULL_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_VIRTIO_INPUT_QUEUE_FULL) || \
    false)

static inline void _nocheck__trace_virtio_input_queue_full(void)
{
    if (trace_event_get_state(TRACE_VIRTIO_INPUT_QUEUE_FULL) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 53 "../git/hw/input/trace-events"
            qemu_log("%d@%zu.%06zu:virtio_input_queue_full " "queue full" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 1230 "trace/trace-hw_input.h"
        } else {
#line 53 "../git/hw/input/trace-events"
            qemu_log("virtio_input_queue_full " "queue full" "\n");
#line 1234 "trace/trace-hw_input.h"
        }
    }
}

static inline void trace_virtio_input_queue_full(void)
{
    if (true) {
        _nocheck__trace_virtio_input_queue_full();
    }
}

#define TRACE_LASIPS2_REG_READ_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_LASIPS2_REG_READ) || \
    false)

static inline void _nocheck__trace_lasips2_reg_read(unsigned int size, int id, uint64_t addr, const char * name, uint64_t val)
{
    if (trace_event_get_state(TRACE_LASIPS2_REG_READ) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 56 "../git/hw/input/trace-events"
            qemu_log("%d@%zu.%06zu:lasips2_reg_read " "%u %d addr 0x%"PRIx64 "%s -> 0x%"PRIx64 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , size, id, addr, name, val);
#line 1261 "trace/trace-hw_input.h"
        } else {
#line 56 "../git/hw/input/trace-events"
            qemu_log("lasips2_reg_read " "%u %d addr 0x%"PRIx64 "%s -> 0x%"PRIx64 "\n", size, id, addr, name, val);
#line 1265 "trace/trace-hw_input.h"
        }
    }
}

static inline void trace_lasips2_reg_read(unsigned int size, int id, uint64_t addr, const char * name, uint64_t val)
{
    if (true) {
        _nocheck__trace_lasips2_reg_read(size, id, addr, name, val);
    }
}

#define TRACE_LASIPS2_REG_WRITE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_LASIPS2_REG_WRITE) || \
    false)

static inline void _nocheck__trace_lasips2_reg_write(unsigned int size, int id, uint64_t addr, const char * name, uint64_t val)
{
    if (trace_event_get_state(TRACE_LASIPS2_REG_WRITE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 57 "../git/hw/input/trace-events"
            qemu_log("%d@%zu.%06zu:lasips2_reg_write " "%u %d addr 0x%"PRIx64 "%s <- 0x%"PRIx64 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , size, id, addr, name, val);
#line 1292 "trace/trace-hw_input.h"
        } else {
#line 57 "../git/hw/input/trace-events"
            qemu_log("lasips2_reg_write " "%u %d addr 0x%"PRIx64 "%s <- 0x%"PRIx64 "\n", size, id, addr, name, val);
#line 1296 "trace/trace-hw_input.h"
        }
    }
}

static inline void trace_lasips2_reg_write(unsigned int size, int id, uint64_t addr, const char * name, uint64_t val)
{
    if (true) {
        _nocheck__trace_lasips2_reg_write(size, id, addr, name, val);
    }
}

#define TRACE_LASIPS2_INTR_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_LASIPS2_INTR) || \
    false)

static inline void _nocheck__trace_lasips2_intr(unsigned int val)
{
    if (trace_event_get_state(TRACE_LASIPS2_INTR) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 58 "../git/hw/input/trace-events"
            qemu_log("%d@%zu.%06zu:lasips2_intr " "%d" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , val);
#line 1323 "trace/trace-hw_input.h"
        } else {
#line 58 "../git/hw/input/trace-events"
            qemu_log("lasips2_intr " "%d" "\n", val);
#line 1327 "trace/trace-hw_input.h"
        }
    }
}

static inline void trace_lasips2_intr(unsigned int val)
{
    if (true) {
        _nocheck__trace_lasips2_intr(val);
    }
}
#endif /* TRACE_HW_INPUT_GENERATED_TRACERS_H */
