/* 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_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_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_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 "../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 142 "trace/trace-hw_input.h"
        } else {
#line 4 "../hw/input/trace-events"
            qemu_log("adb_device_kbd_no_key " "Ignoring NO_KEY" "\n");
#line 146 "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 "../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 173 "trace/trace-hw_input.h"
        } else {
#line 5 "../hw/input/trace-events"
            qemu_log("adb_device_kbd_writereg " "reg %d val 0x%2.2x" "\n", reg, val);
#line 177 "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 "../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 204 "trace/trace-hw_input.h"
        } else {
#line 6 "../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 208 "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 "../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 235 "trace/trace-hw_input.h"
        } else {
#line 7 "../hw/input/trace-events"
            qemu_log("adb_device_kbd_request_change_addr " "change addr to 0x%x" "\n", devaddr);
#line 239 "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 "../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 266 "trace/trace-hw_input.h"
        } else {
#line 8 "../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 270 "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 "../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 297 "trace/trace-hw_input.h"
        } else {
#line 11 "../hw/input/trace-events"
            qemu_log("adb_device_mouse_flush " "flush" "\n");
#line 301 "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 "../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 328 "trace/trace-hw_input.h"
        } else {
#line 12 "../hw/input/trace-events"
            qemu_log("adb_device_mouse_writereg " "reg %d val 0x%2.2x" "\n", reg, val);
#line 332 "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 "../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 359 "trace/trace-hw_input.h"
        } else {
#line 13 "../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 363 "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 "../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 390 "trace/trace-hw_input.h"
        } else {
#line 14 "../hw/input/trace-events"
            qemu_log("adb_device_mouse_request_change_addr " "change addr to 0x%x" "\n", devaddr);
#line 394 "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 "../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 421 "trace/trace-hw_input.h"
        } else {
#line 15 "../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 425 "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 "../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 452 "trace/trace-hw_input.h"
        } else {
#line 18 "../hw/input/trace-events"
            qemu_log("adb_bus_request " "device 0x%x %s cmdsize=%d" "\n", addr, cmd, size);
#line 456 "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 "../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 483 "trace/trace-hw_input.h"
        } else {
#line 19 "../hw/input/trace-events"
            qemu_log("adb_bus_request_done " "device 0x%x %s replysize=%d" "\n", addr, cmd, size);
#line 487 "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 "../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 514 "trace/trace-hw_input.h"
        } else {
#line 20 "../hw/input/trace-events"
            qemu_log("adb_bus_autopoll_block " "blocked: %d" "\n", blocked);
#line 518 "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 "../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 545 "trace/trace-hw_input.h"
        } else {
#line 21 "../hw/input/trace-events"
            qemu_log("adb_bus_autopoll_cb " "executing autopoll_cb with autopoll mask 0x%x" "\n", mask);
#line 549 "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 "../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 576 "trace/trace-hw_input.h"
        } else {
#line 22 "../hw/input/trace-events"
            qemu_log("adb_bus_autopoll_cb_done " "done executing autopoll_cb with autopoll mask 0x%x" "\n", mask);
#line 580 "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 "../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 607 "trace/trace-hw_input.h"
        } else {
#line 25 "../hw/input/trace-events"
            qemu_log("pckbd_kbd_read_data " "0x%02x" "\n", val);
#line 611 "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 "../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 638 "trace/trace-hw_input.h"
        } else {
#line 26 "../hw/input/trace-events"
            qemu_log("pckbd_kbd_read_status " "0x%02x" "\n", status);
#line 642 "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 "../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 669 "trace/trace-hw_input.h"
        } else {
#line 27 "../hw/input/trace-events"
            qemu_log("pckbd_outport_write " "0x%02x" "\n", val);
#line 673 "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 "../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 700 "trace/trace-hw_input.h"
        } else {
#line 28 "../hw/input/trace-events"
            qemu_log("pckbd_kbd_write_command " "0x%02"PRIx64 "\n", val);
#line 704 "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 "../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 731 "trace/trace-hw_input.h"
        } else {
#line 29 "../hw/input/trace-events"
            qemu_log("pckbd_kbd_write_data " "0x%02"PRIx64 "\n", val);
#line 735 "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 "../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 762 "trace/trace-hw_input.h"
        } else {
#line 32 "../hw/input/trace-events"
            qemu_log("ps2_put_keycode " "%p keycode 0x%02x" "\n", opaque, keycode);
#line 766 "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 "../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 793 "trace/trace-hw_input.h"
        } else {
#line 33 "../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 797 "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 "../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 824 "trace/trace-hw_input.h"
        } else {
#line 34 "../hw/input/trace-events"
            qemu_log("ps2_read_data " "%p" "\n", opaque);
#line 828 "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 "../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 855 "trace/trace-hw_input.h"
        } else {
#line 35 "../hw/input/trace-events"
            qemu_log("ps2_set_ledstate " "%p ledstate %d" "\n", s, ledstate);
#line 859 "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 "../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 886 "trace/trace-hw_input.h"
        } else {
#line 36 "../hw/input/trace-events"
            qemu_log("ps2_reset_keyboard " "%p" "\n", s);
#line 890 "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 "../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 917 "trace/trace-hw_input.h"
        } else {
#line 37 "../hw/input/trace-events"
            qemu_log("ps2_write_keyboard " "%p val %d" "\n", opaque, val);
#line 921 "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 "../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 948 "trace/trace-hw_input.h"
        } else {
#line 38 "../hw/input/trace-events"
            qemu_log("ps2_keyboard_set_translation " "%p mode %d" "\n", opaque, mode);
#line 952 "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 "../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 979 "trace/trace-hw_input.h"
        } else {
#line 39 "../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 983 "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 "../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 1010 "trace/trace-hw_input.h"
        } else {
#line 40 "../hw/input/trace-events"
            qemu_log("ps2_mouse_fake_event " "%p" "\n", opaque);
#line 1014 "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 "../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 1041 "trace/trace-hw_input.h"
        } else {
#line 41 "../hw/input/trace-events"
            qemu_log("ps2_write_mouse " "%p val %d" "\n", opaque, val);
#line 1045 "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 "../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 1072 "trace/trace-hw_input.h"
        } else {
#line 42 "../hw/input/trace-events"
            qemu_log("ps2_kbd_reset " "%p" "\n", opaque);
#line 1076 "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 "../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 1103 "trace/trace-hw_input.h"
        } else {
#line 43 "../hw/input/trace-events"
            qemu_log("ps2_mouse_reset " "%p" "\n", opaque);
#line 1107 "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 "../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 1134 "trace/trace-hw_input.h"
        } else {
#line 46 "../hw/input/trace-events"
            qemu_log("hid_kbd_queue_full " "queue full" "\n");
#line 1138 "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 "../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 1165 "trace/trace-hw_input.h"
        } else {
#line 47 "../hw/input/trace-events"
            qemu_log("hid_kbd_queue_empty " "queue empty" "\n");
#line 1169 "trace/trace-hw_input.h"
        }
    }
}

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

#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 50 "../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 1196 "trace/trace-hw_input.h"
        } else {
#line 50 "../hw/input/trace-events"
            qemu_log("virtio_input_queue_full " "queue full" "\n");
#line 1200 "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 53 "../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 1227 "trace/trace-hw_input.h"
        } else {
#line 53 "../hw/input/trace-events"
            qemu_log("lasips2_reg_read " "%u %d addr 0x%"PRIx64 "%s -> 0x%"PRIx64 "\n", size, id, addr, name, val);
#line 1231 "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 54 "../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 1258 "trace/trace-hw_input.h"
        } else {
#line 54 "../hw/input/trace-events"
            qemu_log("lasips2_reg_write " "%u %d addr 0x%"PRIx64 "%s <- 0x%"PRIx64 "\n", size, id, addr, name, val);
#line 1262 "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 55 "../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 1289 "trace/trace-hw_input.h"
        } else {
#line 55 "../hw/input/trace-events"
            qemu_log("lasips2_intr " "%d" "\n", val);
#line 1293 "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 */