/****************************************************************************
** Meta object code from reading C++ file 'ConsoleDebugger.h'
**
** Created by: The Qt Meta Object Compiler version 69 (Qt 6.11.1)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#include "../../../../fceux/src/drivers/Qt/ConsoleDebugger.h"
#include <QtGui/qtextcursor.h>
#include <QtCore/qmetatype.h>

#include <QtCore/qtmochelpers.h>

#include <memory>


#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'ConsoleDebugger.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.11.1. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif

#ifndef Q_CONSTINIT
#define Q_CONSTINIT
#endif

QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
QT_WARNING_DISABLE_GCC("-Wuseless-cast")
namespace {
struct qt_meta_tag_ZN8QAsmViewE_t {};
} // unnamed namespace

template <> constexpr inline auto QAsmView::qt_create_metaobjectdata<qt_meta_tag_ZN8QAsmViewE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QAsmView"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<QAsmView, qt_meta_tag_ZN8QAsmViewE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QAsmView::staticMetaObject = { {
    QMetaObject::SuperData::link<QWidget::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN8QAsmViewE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN8QAsmViewE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN8QAsmViewE_t>.metaTypes,
    nullptr
} };

void QAsmView::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<QAsmView *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

const QMetaObject *QAsmView::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *QAsmView::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN8QAsmViewE_t>.strings))
        return static_cast<void*>(this);
    return QWidget::qt_metacast(_clname);
}

int QAsmView::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QWidget::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN20DebuggerStackDisplayE_t {};
} // unnamed namespace

template <> constexpr inline auto DebuggerStackDisplay::qt_create_metaobjectdata<qt_meta_tag_ZN20DebuggerStackDisplayE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "DebuggerStackDisplay",
        "toggleShowAddr",
        "",
        "sel1BytePerLine",
        "sel2BytesPerLine",
        "sel3BytesPerLine",
        "sel4BytesPerLine"
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'toggleShowAddr'
        QtMocHelpers::SlotData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'sel1BytePerLine'
        QtMocHelpers::SlotData<void()>(3, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'sel2BytesPerLine'
        QtMocHelpers::SlotData<void()>(4, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'sel3BytesPerLine'
        QtMocHelpers::SlotData<void()>(5, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'sel4BytesPerLine'
        QtMocHelpers::SlotData<void()>(6, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DebuggerStackDisplay, qt_meta_tag_ZN20DebuggerStackDisplayE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject DebuggerStackDisplay::staticMetaObject = { {
    QMetaObject::SuperData::link<QPlainTextEdit::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20DebuggerStackDisplayE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20DebuggerStackDisplayE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN20DebuggerStackDisplayE_t>.metaTypes,
    nullptr
} };

void DebuggerStackDisplay::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DebuggerStackDisplay *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->toggleShowAddr(); break;
        case 1: _t->sel1BytePerLine(); break;
        case 2: _t->sel2BytesPerLine(); break;
        case 3: _t->sel3BytesPerLine(); break;
        case 4: _t->sel4BytesPerLine(); break;
        default: ;
        }
    }
    (void)_a;
}

const QMetaObject *DebuggerStackDisplay::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *DebuggerStackDisplay::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20DebuggerStackDisplayE_t>.strings))
        return static_cast<void*>(this);
    return QPlainTextEdit::qt_metacast(_clname);
}

int DebuggerStackDisplay::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QPlainTextEdit::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 5)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 5;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 5)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 5;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN17asmLookAheadPopupE_t {};
} // unnamed namespace

template <> constexpr inline auto asmLookAheadPopup::qt_create_metaobjectdata<qt_meta_tag_ZN17asmLookAheadPopupE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "asmLookAheadPopup"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<asmLookAheadPopup, qt_meta_tag_ZN17asmLookAheadPopupE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject asmLookAheadPopup::staticMetaObject = { {
    QMetaObject::SuperData::link<fceuCustomToolTip::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17asmLookAheadPopupE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17asmLookAheadPopupE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN17asmLookAheadPopupE_t>.metaTypes,
    nullptr
} };

void asmLookAheadPopup::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<asmLookAheadPopup *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

const QMetaObject *asmLookAheadPopup::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *asmLookAheadPopup::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17asmLookAheadPopupE_t>.strings))
        return static_cast<void*>(this);
    return fceuCustomToolTip::qt_metacast(_clname);
}

int asmLookAheadPopup::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = fceuCustomToolTip::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN11ppuRegPopupE_t {};
} // unnamed namespace

template <> constexpr inline auto ppuRegPopup::qt_create_metaobjectdata<qt_meta_tag_ZN11ppuRegPopupE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "ppuRegPopup"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<ppuRegPopup, qt_meta_tag_ZN11ppuRegPopupE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject ppuRegPopup::staticMetaObject = { {
    QMetaObject::SuperData::link<fceuCustomToolTip::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11ppuRegPopupE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11ppuRegPopupE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN11ppuRegPopupE_t>.metaTypes,
    nullptr
} };

void ppuRegPopup::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<ppuRegPopup *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

const QMetaObject *ppuRegPopup::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *ppuRegPopup::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11ppuRegPopupE_t>.strings))
        return static_cast<void*>(this);
    return fceuCustomToolTip::qt_metacast(_clname);
}

int ppuRegPopup::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = fceuCustomToolTip::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN13ppuCtrlRegDpyE_t {};
} // unnamed namespace

template <> constexpr inline auto ppuCtrlRegDpy::qt_create_metaobjectdata<qt_meta_tag_ZN13ppuCtrlRegDpyE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "ppuCtrlRegDpy"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<ppuCtrlRegDpy, qt_meta_tag_ZN13ppuCtrlRegDpyE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject ppuCtrlRegDpy::staticMetaObject = { {
    QMetaObject::SuperData::link<QLineEdit::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13ppuCtrlRegDpyE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13ppuCtrlRegDpyE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN13ppuCtrlRegDpyE_t>.metaTypes,
    nullptr
} };

void ppuCtrlRegDpy::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<ppuCtrlRegDpy *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

const QMetaObject *ppuCtrlRegDpy::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *ppuCtrlRegDpy::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13ppuCtrlRegDpyE_t>.strings))
        return static_cast<void*>(this);
    return QLineEdit::qt_metacast(_clname);
}

int ppuCtrlRegDpy::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QLineEdit::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN14DebuggerTabBarE_t {};
} // unnamed namespace

template <> constexpr inline auto DebuggerTabBar::qt_create_metaobjectdata<qt_meta_tag_ZN14DebuggerTabBarE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "DebuggerTabBar",
        "beginDragOut",
        ""
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'beginDragOut'
        QtMocHelpers::SignalData<void(int)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 2 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DebuggerTabBar, qt_meta_tag_ZN14DebuggerTabBarE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject DebuggerTabBar::staticMetaObject = { {
    QMetaObject::SuperData::link<QTabBar::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14DebuggerTabBarE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14DebuggerTabBarE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN14DebuggerTabBarE_t>.metaTypes,
    nullptr
} };

void DebuggerTabBar::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DebuggerTabBar *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->beginDragOut((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (DebuggerTabBar::*)(int )>(_a, &DebuggerTabBar::beginDragOut, 0))
            return;
    }
}

const QMetaObject *DebuggerTabBar::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *DebuggerTabBar::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14DebuggerTabBarE_t>.strings))
        return static_cast<void*>(this);
    return QTabBar::qt_metacast(_clname);
}

int DebuggerTabBar::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QTabBar::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 1;
    }
    return _id;
}

// SIGNAL 0
void DebuggerTabBar::beginDragOut(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN17DebuggerTabWidgetE_t {};
} // unnamed namespace

template <> constexpr inline auto DebuggerTabWidget::qt_create_metaobjectdata<qt_meta_tag_ZN17DebuggerTabWidgetE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "DebuggerTabWidget"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DebuggerTabWidget, qt_meta_tag_ZN17DebuggerTabWidgetE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject DebuggerTabWidget::staticMetaObject = { {
    QMetaObject::SuperData::link<QTabWidget::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17DebuggerTabWidgetE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17DebuggerTabWidgetE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN17DebuggerTabWidgetE_t>.metaTypes,
    nullptr
} };

void DebuggerTabWidget::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DebuggerTabWidget *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

const QMetaObject *DebuggerTabWidget::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *DebuggerTabWidget::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17DebuggerTabWidgetE_t>.strings))
        return static_cast<void*>(this);
    return QTabWidget::qt_metacast(_clname);
}

int DebuggerTabWidget::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QTabWidget::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN18DebugBreakOnDialogE_t {};
} // unnamed namespace

template <> constexpr inline auto DebugBreakOnDialog::qt_create_metaobjectdata<qt_meta_tag_ZN18DebugBreakOnDialogE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "DebugBreakOnDialog",
        "closeWindow",
        "",
        "ret",
        "setThreshold",
        "val",
        "text",
        "incrThreshold",
        "refModeChanged",
        "syncToCurrent",
        "resetCounters",
        "resetDeltas"
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'closeWindow'
        QtMocHelpers::SlotData<void(int)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 3 },
        }}),
        // Slot 'setThreshold'
        QtMocHelpers::SlotData<void(unsigned long long int)>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 5 },
        }}),
        // Slot 'setThreshold'
        QtMocHelpers::SlotData<void(const QString &)>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 6 },
        }}),
        // Slot 'incrThreshold'
        QtMocHelpers::SlotData<void(int)>(7, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 2 },
        }}),
        // Slot 'refModeChanged'
        QtMocHelpers::SlotData<void(bool)>(8, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 2 },
        }}),
        // Slot 'syncToCurrent'
        QtMocHelpers::SlotData<void()>(9, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'resetCounters'
        QtMocHelpers::SlotData<void()>(10, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'resetDeltas'
        QtMocHelpers::SlotData<void()>(11, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DebugBreakOnDialog, qt_meta_tag_ZN18DebugBreakOnDialogE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject DebugBreakOnDialog::staticMetaObject = { {
    QMetaObject::SuperData::link<QDialog::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18DebugBreakOnDialogE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18DebugBreakOnDialogE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN18DebugBreakOnDialogE_t>.metaTypes,
    nullptr
} };

void DebugBreakOnDialog::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DebugBreakOnDialog *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->closeWindow((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 1: _t->setThreshold((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 2: _t->setThreshold((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 3: _t->incrThreshold((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 4: _t->refModeChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 5: _t->syncToCurrent(); break;
        case 6: _t->resetCounters(); break;
        case 7: _t->resetDeltas(); break;
        default: ;
        }
    }
}

const QMetaObject *DebugBreakOnDialog::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *DebugBreakOnDialog::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18DebugBreakOnDialogE_t>.strings))
        return static_cast<void*>(this);
    return QDialog::qt_metacast(_clname);
}

int DebugBreakOnDialog::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QDialog::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 8)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 8;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 8)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 8;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN24DebuggerBreakpointEditorE_t {};
} // unnamed namespace

template <> constexpr inline auto DebuggerBreakpointEditor::qt_create_metaobjectdata<qt_meta_tag_ZN24DebuggerBreakpointEditorE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "DebuggerBreakpointEditor",
        "closeWindow",
        "",
        "ret",
        "typeChanged",
        "checked",
        "addressTextChanged",
        "text",
        "conditionTextChanged"
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'closeWindow'
        QtMocHelpers::SlotData<void(int)>(1, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 3 },
        }}),
        // Slot 'typeChanged'
        QtMocHelpers::SlotData<void(bool)>(4, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 5 },
        }}),
        // Slot 'addressTextChanged'
        QtMocHelpers::SlotData<void(const QString &)>(6, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 7 },
        }}),
        // Slot 'conditionTextChanged'
        QtMocHelpers::SlotData<void(const QString &)>(8, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 7 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DebuggerBreakpointEditor, qt_meta_tag_ZN24DebuggerBreakpointEditorE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject DebuggerBreakpointEditor::staticMetaObject = { {
    QMetaObject::SuperData::link<QDialog::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24DebuggerBreakpointEditorE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24DebuggerBreakpointEditorE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN24DebuggerBreakpointEditorE_t>.metaTypes,
    nullptr
} };

void DebuggerBreakpointEditor::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DebuggerBreakpointEditor *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->closeWindow((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 1: _t->typeChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 2: _t->addressTextChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 3: _t->conditionTextChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        default: ;
        }
    }
}

const QMetaObject *DebuggerBreakpointEditor::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *DebuggerBreakpointEditor::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24DebuggerBreakpointEditorE_t>.strings))
        return static_cast<void*>(this);
    return QDialog::qt_metacast(_clname);
}

int DebuggerBreakpointEditor::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QDialog::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 4)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 4;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 4)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 4;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN15ConsoleDebuggerE_t {};
} // unnamed namespace

template <> constexpr inline auto ConsoleDebugger::qt_create_metaobjectdata<qt_meta_tag_ZN15ConsoleDebuggerE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "ConsoleDebugger",
        "closeWindow",
        "",
        "asmViewCtxMenuGoTo",
        "asmViewCtxMenuAddBP",
        "asmViewCtxMenuAddBM",
        "asmViewCtxMenuAddSym",
        "asmViewCtxMenuOpenHexEdit",
        "asmViewCtxMenuRunToCursor",
        "moveTab",
        "QWidget*",
        "w",
        "row",
        "column",
        "ld65ImportDebug",
        "updatePeriodic",
        "hbarChanged",
        "value",
        "vbarChanged",
        "debugRunCB",
        "debugStepIntoCB",
        "debugStepOutCB",
        "debugStepOverCB",
        "debugStepBackCB",
        "debugRunToCursorCB",
        "debugRunLineCB",
        "debugRunLine128CB",
        "openGotoAddrDialog",
        "openChangePcDialog",
        "seekPCCB",
        "add_BP_CB",
        "edit_BP_CB",
        "delete_BP_CB",
        "add_BM_CB",
        "edit_BM_CB",
        "delete_BM_CB",
        "setLayoutOption",
        "layout",
        "resizeToMinimumSizeHint",
        "resetCountersCB",
        "reloadSymbolsCB",
        "saveSymbolsCB",
        "displayByteCodesCB",
        "displayTraceDataCB",
        "displayROMoffsetCB",
        "symbolDebugEnableCB",
        "registerNameEnableCB",
        "autoOpenDebugCB",
        "debFileAutoLoadCB",
        "autoStartTraceLoggerOnOpen",
        "breakOnBadOpcodeCB",
        "breakOnNewCodeCB",
        "breakOnNewDataCB",
        "breakOnCyclesCB",
        "breakOnInstructionsCB",
        "bpItemClicked",
        "QTreeWidgetItem*",
        "item",
        "bmItemClicked",
        "bmItemDoubleClicked",
        "cpuCycleThresChanged",
        "txt",
        "instructionsThresChanged",
        "selBmAddrChanged",
        "pcSetPlaceTop",
        "pcSetPlaceUpperMid",
        "pcSetPlaceCenter",
        "pcSetPlaceLowerMid",
        "pcSetPlaceBottom",
        "pcSetPlaceCustom",
        "changeAsmFontCB",
        "changeStackFontCB",
        "changeCpuFontCB",
        "navHistBackCB",
        "navHistForwardCB"
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'closeWindow'
        QtMocHelpers::SlotData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'asmViewCtxMenuGoTo'
        QtMocHelpers::SlotData<void()>(3, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'asmViewCtxMenuAddBP'
        QtMocHelpers::SlotData<void()>(4, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'asmViewCtxMenuAddBM'
        QtMocHelpers::SlotData<void()>(5, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'asmViewCtxMenuAddSym'
        QtMocHelpers::SlotData<void()>(6, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'asmViewCtxMenuOpenHexEdit'
        QtMocHelpers::SlotData<void()>(7, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'asmViewCtxMenuRunToCursor'
        QtMocHelpers::SlotData<void()>(8, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'moveTab'
        QtMocHelpers::SlotData<void(QWidget *, int, int)>(9, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 10, 11 }, { QMetaType::Int, 12 }, { QMetaType::Int, 13 },
        }}),
        // Slot 'ld65ImportDebug'
        QtMocHelpers::SlotData<void()>(14, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'updatePeriodic'
        QtMocHelpers::SlotData<void()>(15, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'hbarChanged'
        QtMocHelpers::SlotData<void(int)>(16, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 17 },
        }}),
        // Slot 'vbarChanged'
        QtMocHelpers::SlotData<void(int)>(18, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 17 },
        }}),
        // Slot 'debugRunCB'
        QtMocHelpers::SlotData<void()>(19, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'debugStepIntoCB'
        QtMocHelpers::SlotData<void()>(20, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'debugStepOutCB'
        QtMocHelpers::SlotData<void()>(21, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'debugStepOverCB'
        QtMocHelpers::SlotData<void()>(22, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'debugStepBackCB'
        QtMocHelpers::SlotData<void()>(23, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'debugRunToCursorCB'
        QtMocHelpers::SlotData<void()>(24, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'debugRunLineCB'
        QtMocHelpers::SlotData<void()>(25, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'debugRunLine128CB'
        QtMocHelpers::SlotData<void()>(26, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'openGotoAddrDialog'
        QtMocHelpers::SlotData<void()>(27, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'openChangePcDialog'
        QtMocHelpers::SlotData<void()>(28, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'seekPCCB'
        QtMocHelpers::SlotData<void()>(29, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'add_BP_CB'
        QtMocHelpers::SlotData<void()>(30, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'edit_BP_CB'
        QtMocHelpers::SlotData<void()>(31, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'delete_BP_CB'
        QtMocHelpers::SlotData<void()>(32, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'add_BM_CB'
        QtMocHelpers::SlotData<void()>(33, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'edit_BM_CB'
        QtMocHelpers::SlotData<void()>(34, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'delete_BM_CB'
        QtMocHelpers::SlotData<void()>(35, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'setLayoutOption'
        QtMocHelpers::SlotData<void(int)>(36, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 37 },
        }}),
        // Slot 'resizeToMinimumSizeHint'
        QtMocHelpers::SlotData<void()>(38, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'resetCountersCB'
        QtMocHelpers::SlotData<void()>(39, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'reloadSymbolsCB'
        QtMocHelpers::SlotData<void()>(40, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'saveSymbolsCB'
        QtMocHelpers::SlotData<void()>(41, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'displayByteCodesCB'
        QtMocHelpers::SlotData<void(bool)>(42, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 17 },
        }}),
        // Slot 'displayTraceDataCB'
        QtMocHelpers::SlotData<void(bool)>(43, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 17 },
        }}),
        // Slot 'displayROMoffsetCB'
        QtMocHelpers::SlotData<void(bool)>(44, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 17 },
        }}),
        // Slot 'symbolDebugEnableCB'
        QtMocHelpers::SlotData<void(bool)>(45, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 17 },
        }}),
        // Slot 'registerNameEnableCB'
        QtMocHelpers::SlotData<void(bool)>(46, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 17 },
        }}),
        // Slot 'autoOpenDebugCB'
        QtMocHelpers::SlotData<void(bool)>(47, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 17 },
        }}),
        // Slot 'debFileAutoLoadCB'
        QtMocHelpers::SlotData<void(bool)>(48, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 17 },
        }}),
        // Slot 'autoStartTraceLoggerOnOpen'
        QtMocHelpers::SlotData<void(bool)>(49, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 17 },
        }}),
        // Slot 'breakOnBadOpcodeCB'
        QtMocHelpers::SlotData<void(bool)>(50, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 17 },
        }}),
        // Slot 'breakOnNewCodeCB'
        QtMocHelpers::SlotData<void(bool)>(51, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 17 },
        }}),
        // Slot 'breakOnNewDataCB'
        QtMocHelpers::SlotData<void(bool)>(52, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 17 },
        }}),
        // Slot 'breakOnCyclesCB'
        QtMocHelpers::SlotData<void(bool)>(53, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 17 },
        }}),
        // Slot 'breakOnInstructionsCB'
        QtMocHelpers::SlotData<void(bool)>(54, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 17 },
        }}),
        // Slot 'bpItemClicked'
        QtMocHelpers::SlotData<void(QTreeWidgetItem *, int)>(55, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 56, 57 }, { QMetaType::Int, 13 },
        }}),
        // Slot 'bmItemClicked'
        QtMocHelpers::SlotData<void(QTreeWidgetItem *, int)>(58, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 56, 57 }, { QMetaType::Int, 13 },
        }}),
        // Slot 'bmItemDoubleClicked'
        QtMocHelpers::SlotData<void(QTreeWidgetItem *, int)>(59, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 56, 57 }, { QMetaType::Int, 13 },
        }}),
        // Slot 'cpuCycleThresChanged'
        QtMocHelpers::SlotData<void(const QString &)>(60, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 61 },
        }}),
        // Slot 'instructionsThresChanged'
        QtMocHelpers::SlotData<void(const QString &)>(62, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 61 },
        }}),
        // Slot 'selBmAddrChanged'
        QtMocHelpers::SlotData<void(const QString &)>(63, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 61 },
        }}),
        // Slot 'pcSetPlaceTop'
        QtMocHelpers::SlotData<void()>(64, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'pcSetPlaceUpperMid'
        QtMocHelpers::SlotData<void()>(65, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'pcSetPlaceCenter'
        QtMocHelpers::SlotData<void()>(66, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'pcSetPlaceLowerMid'
        QtMocHelpers::SlotData<void()>(67, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'pcSetPlaceBottom'
        QtMocHelpers::SlotData<void()>(68, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'pcSetPlaceCustom'
        QtMocHelpers::SlotData<void()>(69, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'changeAsmFontCB'
        QtMocHelpers::SlotData<void()>(70, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'changeStackFontCB'
        QtMocHelpers::SlotData<void()>(71, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'changeCpuFontCB'
        QtMocHelpers::SlotData<void()>(72, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'navHistBackCB'
        QtMocHelpers::SlotData<void()>(73, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'navHistForwardCB'
        QtMocHelpers::SlotData<void()>(74, 2, QMC::AccessPrivate, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<ConsoleDebugger, qt_meta_tag_ZN15ConsoleDebuggerE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject ConsoleDebugger::staticMetaObject = { {
    QMetaObject::SuperData::link<QDialog::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN15ConsoleDebuggerE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN15ConsoleDebuggerE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN15ConsoleDebuggerE_t>.metaTypes,
    nullptr
} };

void ConsoleDebugger::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<ConsoleDebugger *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->closeWindow(); break;
        case 1: _t->asmViewCtxMenuGoTo(); break;
        case 2: _t->asmViewCtxMenuAddBP(); break;
        case 3: _t->asmViewCtxMenuAddBM(); break;
        case 4: _t->asmViewCtxMenuAddSym(); break;
        case 5: _t->asmViewCtxMenuOpenHexEdit(); break;
        case 6: _t->asmViewCtxMenuRunToCursor(); break;
        case 7: _t->moveTab((*reinterpret_cast<std::add_pointer_t<QWidget*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3]))); break;
        case 8: _t->ld65ImportDebug(); break;
        case 9: _t->updatePeriodic(); break;
        case 10: _t->hbarChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 11: _t->vbarChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 12: _t->debugRunCB(); break;
        case 13: _t->debugStepIntoCB(); break;
        case 14: _t->debugStepOutCB(); break;
        case 15: _t->debugStepOverCB(); break;
        case 16: _t->debugStepBackCB(); break;
        case 17: _t->debugRunToCursorCB(); break;
        case 18: _t->debugRunLineCB(); break;
        case 19: _t->debugRunLine128CB(); break;
        case 20: _t->openGotoAddrDialog(); break;
        case 21: _t->openChangePcDialog(); break;
        case 22: _t->seekPCCB(); break;
        case 23: _t->add_BP_CB(); break;
        case 24: _t->edit_BP_CB(); break;
        case 25: _t->delete_BP_CB(); break;
        case 26: _t->add_BM_CB(); break;
        case 27: _t->edit_BM_CB(); break;
        case 28: _t->delete_BM_CB(); break;
        case 29: _t->setLayoutOption((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 30: _t->resizeToMinimumSizeHint(); break;
        case 31: _t->resetCountersCB(); break;
        case 32: _t->reloadSymbolsCB(); break;
        case 33: _t->saveSymbolsCB(); break;
        case 34: _t->displayByteCodesCB((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 35: _t->displayTraceDataCB((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 36: _t->displayROMoffsetCB((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 37: _t->symbolDebugEnableCB((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 38: _t->registerNameEnableCB((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 39: _t->autoOpenDebugCB((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 40: _t->debFileAutoLoadCB((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 41: _t->autoStartTraceLoggerOnOpen((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 42: _t->breakOnBadOpcodeCB((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 43: _t->breakOnNewCodeCB((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 44: _t->breakOnNewDataCB((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 45: _t->breakOnCyclesCB((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 46: _t->breakOnInstructionsCB((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 47: _t->bpItemClicked((*reinterpret_cast<std::add_pointer_t<QTreeWidgetItem*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 48: _t->bmItemClicked((*reinterpret_cast<std::add_pointer_t<QTreeWidgetItem*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 49: _t->bmItemDoubleClicked((*reinterpret_cast<std::add_pointer_t<QTreeWidgetItem*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 50: _t->cpuCycleThresChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 51: _t->instructionsThresChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 52: _t->selBmAddrChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 53: _t->pcSetPlaceTop(); break;
        case 54: _t->pcSetPlaceUpperMid(); break;
        case 55: _t->pcSetPlaceCenter(); break;
        case 56: _t->pcSetPlaceLowerMid(); break;
        case 57: _t->pcSetPlaceBottom(); break;
        case 58: _t->pcSetPlaceCustom(); break;
        case 59: _t->changeAsmFontCB(); break;
        case 60: _t->changeStackFontCB(); break;
        case 61: _t->changeCpuFontCB(); break;
        case 62: _t->navHistBackCB(); break;
        case 63: _t->navHistForwardCB(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 7:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QWidget* >(); break;
            }
            break;
        }
    }
}

const QMetaObject *ConsoleDebugger::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *ConsoleDebugger::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN15ConsoleDebuggerE_t>.strings))
        return static_cast<void*>(this);
    return QDialog::qt_metacast(_clname);
}

int ConsoleDebugger::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QDialog::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 64)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 64;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 64)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 64;
    }
    return _id;
}
QT_WARNING_POP
