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

#include "../../../../../../stellarium/plugins/Calendars/src/NewHinduCalendar.hpp"
#include <QtCore/qmetatype.h>
#include <QtCore/QList>

#include <QtCore/qtmochelpers.h>

#include <memory>


#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'NewHinduCalendar.hpp' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.11.0. 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_ZN16NewHinduCalendarE_t {};
} // unnamed namespace

template <> constexpr inline auto NewHinduCalendar::qt_create_metaobjectdata<qt_meta_tag_ZN16NewHinduCalendarE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "NewHinduCalendar",
        "retranslate",
        "",
        "setJD",
        "JD",
        "setDate",
        "QList<int>",
        "parts",
        "getDateStrings",
        "getFormattedDateString",
        "hinduSineTable",
        "entry",
        "hinduSine",
        "theta",
        "hinduArcsin",
        "amp",
        "hinduMeanPosition",
        "rd_ut",
        "period",
        "hinduTruePosition",
        "size",
        "anomalistic",
        "change",
        "hinduSolarLongitude",
        "hinduZodiac",
        "hinduLunarLongitude",
        "hinduLunarPhase",
        "hinduLunarDayFromMoment",
        "hinduNewMoonBefore",
        "hinduCalendarYear",
        "hinduSolarFromFixed",
        "rd",
        "fixedFromHinduSolar",
        "hinduLunarFromFixed",
        "fixedFromHinduLunar",
        "hinduAscensionalDifference",
        "StelLocation",
        "loc",
        "hinduTropicalLongitude",
        "hinduSolarSiderealDifference",
        "hinduDailyMotion",
        "hinduRisingSign",
        "hinduEquationOfTime",
        "hinduSunrise",
        "hinduSunset",
        "hinduStandardFromSundial",
        "hinduFullMoonFromFixed",
        "fixedFromHinduFullMoon",
        "hinduExpunged",
        "lYear",
        "lMonth",
        "altHinduSunrise",
        "siderealSolarLongitude",
        "ayanamsha",
        "siderealStart",
        "astroHinduSunset",
        "siderealZodiac",
        "astroHinduCalendarYear",
        "astroHinduSolarFromFixed",
        "fixedFromAstroHinduSolar",
        "date",
        "astroLunarDayFromMoment",
        "astroHinduLunarFromFixed",
        "fixedFromAstroHinduLunar",
        "hinduSolarLongitudeInv",
        "lng",
        "rdA",
        "rdB",
        "hinduSolarLongitudeAtOrAfter",
        "lambda",
        "meshaSamkranti",
        "gYear",
        "hinduLunarPhaseInv",
        "phase",
        "hinduLunarDayAtOrAfter",
        "k",
        "hinduLunarNewYear",
        "hinduLunarOnOrBefore",
        "date1",
        "date2",
        "hinduDateOccur",
        "lDay",
        "hinduLunarHoliday",
        "diwali",
        "hinduTithiOccur",
        "tithi",
        "hinduLunarEvent",
        "shiva",
        "rama",
        "hinduLunarStation",
        "karana",
        "n",
        "karanaForDay",
        "yoga",
        "sacredWednesdays",
        "sacredWednesdaysInRange",
        "range"
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'retranslate'
        QtMocHelpers::SlotData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setJD'
        QtMocHelpers::SlotData<void(double)>(3, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 4 },
        }}),
        // Slot 'setDate'
        QtMocHelpers::SlotData<void(const QVector<int> &)>(5, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 6, 7 },
        }}),
        // Slot 'getDateStrings'
        QtMocHelpers::SlotData<QStringList() const>(8, 2, QMC::AccessPublic, QMetaType::QStringList),
        // Slot 'getFormattedDateString'
        QtMocHelpers::SlotData<QString() const>(9, 2, QMC::AccessPublic, QMetaType::QString),
        // Slot 'hinduSineTable'
        QtMocHelpers::SlotData<double(const int)>(10, 2, QMC::AccessPublic, QMetaType::Double, {{
            { QMetaType::Int, 11 },
        }}),
        // Slot 'hinduSine'
        QtMocHelpers::SlotData<double(const double)>(12, 2, QMC::AccessPublic, QMetaType::Double, {{
            { QMetaType::Double, 13 },
        }}),
        // Slot 'hinduArcsin'
        QtMocHelpers::SlotData<double(const double)>(14, 2, QMC::AccessPublic, QMetaType::Double, {{
            { QMetaType::Double, 15 },
        }}),
        // Slot 'hinduMeanPosition'
        QtMocHelpers::SlotData<double(const double, const double)>(16, 2, QMC::AccessPublic, QMetaType::Double, {{
            { QMetaType::Double, 17 }, { QMetaType::Double, 18 },
        }}),
        // Slot 'hinduTruePosition'
        QtMocHelpers::SlotData<double(const double, const double, const double, const double, const double)>(19, 2, QMC::AccessPublic, QMetaType::Double, {{
            { QMetaType::Double, 17 }, { QMetaType::Double, 18 }, { QMetaType::Double, 20 }, { QMetaType::Double, 21 },
            { QMetaType::Double, 22 },
        }}),
        // Slot 'hinduSolarLongitude'
        QtMocHelpers::SlotData<double(const double)>(23, 2, QMC::AccessPublic, QMetaType::Double, {{
            { QMetaType::Double, 17 },
        }}),
        // Slot 'hinduZodiac'
        QtMocHelpers::SlotData<int(const double)>(24, 2, QMC::AccessPublic, QMetaType::Int, {{
            { QMetaType::Double, 17 },
        }}),
        // Slot 'hinduLunarLongitude'
        QtMocHelpers::SlotData<double(const double)>(25, 2, QMC::AccessPublic, QMetaType::Double, {{
            { QMetaType::Double, 17 },
        }}),
        // Slot 'hinduLunarPhase'
        QtMocHelpers::SlotData<double(const double)>(26, 2, QMC::AccessPublic, QMetaType::Double, {{
            { QMetaType::Double, 17 },
        }}),
        // Slot 'hinduLunarDayFromMoment'
        QtMocHelpers::SlotData<int(const double)>(27, 2, QMC::AccessPublic, QMetaType::Int, {{
            { QMetaType::Double, 17 },
        }}),
        // Slot 'hinduNewMoonBefore'
        QtMocHelpers::SlotData<double(const double)>(28, 2, QMC::AccessPublic, QMetaType::Double, {{
            { QMetaType::Double, 17 },
        }}),
        // Slot 'hinduCalendarYear'
        QtMocHelpers::SlotData<int(const double)>(29, 2, QMC::AccessPublic, QMetaType::Int, {{
            { QMetaType::Double, 17 },
        }}),
        // Slot 'hinduSolarFromFixed'
        QtMocHelpers::SlotData<QVector<int>(int)>(30, 2, QMC::AccessPublic, 0x80000000 | 6, {{
            { QMetaType::Int, 31 },
        }}),
        // Slot 'fixedFromHinduSolar'
        QtMocHelpers::SlotData<int(const QVector<int> &)>(32, 2, QMC::AccessPublic, QMetaType::Int, {{
            { 0x80000000 | 6, 7 },
        }}),
        // Slot 'hinduLunarFromFixed'
        QtMocHelpers::SlotData<QVector<int>(int)>(33, 2, QMC::AccessPublic, 0x80000000 | 6, {{
            { QMetaType::Int, 31 },
        }}),
        // Slot 'fixedFromHinduLunar'
        QtMocHelpers::SlotData<int(const QVector<int> &)>(34, 2, QMC::AccessPublic, QMetaType::Int, {{
            { 0x80000000 | 6, 7 },
        }}),
        // Slot 'hinduAscensionalDifference'
        QtMocHelpers::SlotData<double(const int, const StelLocation &)>(35, 2, QMC::AccessPublic, QMetaType::Double, {{
            { QMetaType::Int, 31 }, { 0x80000000 | 36, 37 },
        }}),
        // Slot 'hinduAscensionalDifference'
        QtMocHelpers::SlotData<double(const int)>(35, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Double, {{
            { QMetaType::Int, 31 },
        }}),
        // Slot 'hinduAscensionalDifference'
        QtMocHelpers::SlotData<double(const int, const QString &)>(35, 2, QMC::AccessPublic, QMetaType::Double, {{
            { QMetaType::Int, 31 }, { QMetaType::QString, 37 },
        }}),
        // Slot 'hinduTropicalLongitude'
        QtMocHelpers::SlotData<double(const double)>(38, 2, QMC::AccessPublic, QMetaType::Double, {{
            { QMetaType::Double, 17 },
        }}),
        // Slot 'hinduSolarSiderealDifference'
        QtMocHelpers::SlotData<double(const double)>(39, 2, QMC::AccessPublic, QMetaType::Double, {{
            { QMetaType::Double, 17 },
        }}),
        // Slot 'hinduDailyMotion'
        QtMocHelpers::SlotData<double(const double)>(40, 2, QMC::AccessPublic, QMetaType::Double, {{
            { QMetaType::Double, 17 },
        }}),
        // Slot 'hinduRisingSign'
        QtMocHelpers::SlotData<double(const double)>(41, 2, QMC::AccessPublic, QMetaType::Double, {{
            { QMetaType::Double, 17 },
        }}),
        // Slot 'hinduEquationOfTime'
        QtMocHelpers::SlotData<double(const double)>(42, 2, QMC::AccessPublic, QMetaType::Double, {{
            { QMetaType::Double, 17 },
        }}),
        // Slot 'hinduSunrise'
        QtMocHelpers::SlotData<double(const int)>(43, 2, QMC::AccessPublic, QMetaType::Double, {{
            { QMetaType::Int, 31 },
        }}),
        // Slot 'hinduSunset'
        QtMocHelpers::SlotData<double(const int)>(44, 2, QMC::AccessPublic, QMetaType::Double, {{
            { QMetaType::Int, 31 },
        }}),
        // Slot 'hinduStandardFromSundial'
        QtMocHelpers::SlotData<double(const int)>(45, 2, QMC::AccessPublic, QMetaType::Double, {{
            { QMetaType::Int, 17 },
        }}),
        // Slot 'hinduFullMoonFromFixed'
        QtMocHelpers::SlotData<QVector<int>(int)>(46, 2, QMC::AccessPublic, 0x80000000 | 6, {{
            { QMetaType::Int, 31 },
        }}),
        // Slot 'fixedFromHinduFullMoon'
        QtMocHelpers::SlotData<int(const QVector<int> &)>(47, 2, QMC::AccessPublic, QMetaType::Int, {{
            { 0x80000000 | 6, 7 },
        }}),
        // Slot 'hinduExpunged'
        QtMocHelpers::SlotData<bool(const int, const int)>(48, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::Int, 49 }, { QMetaType::Int, 50 },
        }}),
        // Slot 'altHinduSunrise'
        QtMocHelpers::SlotData<double(const int)>(51, 2, QMC::AccessPublic, QMetaType::Double, {{
            { QMetaType::Int, 31 },
        }}),
        // Slot 'siderealSolarLongitude'
        QtMocHelpers::SlotData<double(const double)>(52, 2, QMC::AccessPublic, QMetaType::Double, {{
            { QMetaType::Double, 17 },
        }}),
        // Slot 'ayanamsha'
        QtMocHelpers::SlotData<double(const double)>(53, 2, QMC::AccessPublic, QMetaType::Double, {{
            { QMetaType::Double, 17 },
        }}),
        // Slot 'siderealStart'
        QtMocHelpers::SlotData<double()>(54, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'astroHinduSunset'
        QtMocHelpers::SlotData<double(const int)>(55, 2, QMC::AccessPublic, QMetaType::Double, {{
            { QMetaType::Int, 31 },
        }}),
        // Slot 'siderealZodiac'
        QtMocHelpers::SlotData<int(const double)>(56, 2, QMC::AccessPublic, QMetaType::Int, {{
            { QMetaType::Double, 17 },
        }}),
        // Slot 'astroHinduCalendarYear'
        QtMocHelpers::SlotData<int(const double)>(57, 2, QMC::AccessPublic, QMetaType::Int, {{
            { QMetaType::Double, 17 },
        }}),
        // Slot 'astroHinduSolarFromFixed'
        QtMocHelpers::SlotData<QVector<int>(const int)>(58, 2, QMC::AccessPublic, 0x80000000 | 6, {{
            { QMetaType::Int, 31 },
        }}),
        // Slot 'fixedFromAstroHinduSolar'
        QtMocHelpers::SlotData<int(const QVector<int> &)>(59, 2, QMC::AccessPublic, QMetaType::Int, {{
            { 0x80000000 | 6, 60 },
        }}),
        // Slot 'astroLunarDayFromMoment'
        QtMocHelpers::SlotData<int(const double)>(61, 2, QMC::AccessPublic, QMetaType::Int, {{
            { QMetaType::Double, 17 },
        }}),
        // Slot 'astroHinduLunarFromFixed'
        QtMocHelpers::SlotData<QVector<int>(const int)>(62, 2, QMC::AccessPublic, 0x80000000 | 6, {{
            { QMetaType::Int, 31 },
        }}),
        // Slot 'fixedFromAstroHinduLunar'
        QtMocHelpers::SlotData<int(const QVector<int> &)>(63, 2, QMC::AccessPublic, QMetaType::Int, {{
            { 0x80000000 | 6, 7 },
        }}),
        // Slot 'hinduSolarLongitudeInv'
        QtMocHelpers::SlotData<double(double, double, double)>(64, 2, QMC::AccessPublic, QMetaType::Double, {{
            { QMetaType::Double, 65 }, { QMetaType::Double, 66 }, { QMetaType::Double, 67 },
        }}),
        // Slot 'hinduSolarLongitudeAtOrAfter'
        QtMocHelpers::SlotData<double(const double, const double)>(68, 2, QMC::AccessPublic, QMetaType::Double, {{
            { QMetaType::Double, 69 }, { QMetaType::Double, 17 },
        }}),
        // Slot 'meshaSamkranti'
        QtMocHelpers::SlotData<double(const int)>(70, 2, QMC::AccessPublic, QMetaType::Double, {{
            { QMetaType::Int, 71 },
        }}),
        // Slot 'hinduLunarPhaseInv'
        QtMocHelpers::SlotData<double(double, double, double)>(72, 2, QMC::AccessPublic, QMetaType::Double, {{
            { QMetaType::Double, 73 }, { QMetaType::Double, 66 }, { QMetaType::Double, 67 },
        }}),
        // Slot 'hinduLunarDayAtOrAfter'
        QtMocHelpers::SlotData<double(const double, const double)>(74, 2, QMC::AccessPublic, QMetaType::Double, {{
            { QMetaType::Double, 75 }, { QMetaType::Double, 17 },
        }}),
        // Slot 'hinduLunarNewYear'
        QtMocHelpers::SlotData<double(const int)>(76, 2, QMC::AccessPublic, QMetaType::Double, {{
            { QMetaType::Int, 71 },
        }}),
        // Slot 'hinduLunarOnOrBefore'
        QtMocHelpers::SlotData<bool(const QVector<int> &, const QVector<int> &)>(77, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { 0x80000000 | 6, 78 }, { 0x80000000 | 6, 79 },
        }}),
        // Slot 'hinduDateOccur'
        QtMocHelpers::SlotData<int(const int, const int, const int)>(80, 2, QMC::AccessPublic, QMetaType::Int, {{
            { QMetaType::Int, 49 }, { QMetaType::Int, 50 }, { QMetaType::Int, 81 },
        }}),
        // Slot 'hinduLunarHoliday'
        QtMocHelpers::SlotData<QVector<int>(const int, const int, const int)>(82, 2, QMC::AccessPublic, 0x80000000 | 6, {{
            { QMetaType::Int, 50 }, { QMetaType::Int, 81 }, { QMetaType::Int, 71 },
        }}),
        // Slot 'diwali'
        QtMocHelpers::SlotData<QVector<int>(const int)>(83, 2, QMC::AccessPublic, 0x80000000 | 6, {{
            { QMetaType::Int, 71 },
        }}),
        // Slot 'hinduTithiOccur'
        QtMocHelpers::SlotData<int(const int, const int, const double, const int)>(84, 2, QMC::AccessPublic, QMetaType::Int, {{
            { QMetaType::Int, 50 }, { QMetaType::Int, 85 }, { QMetaType::Double, 17 }, { QMetaType::Int, 49 },
        }}),
        // Slot 'hinduLunarEvent'
        QtMocHelpers::SlotData<QVector<int>(const int, const int, const double, const int)>(86, 2, QMC::AccessPublic, 0x80000000 | 6, {{
            { QMetaType::Int, 50 }, { QMetaType::Int, 85 }, { QMetaType::Double, 17 }, { QMetaType::Int, 71 },
        }}),
        // Slot 'shiva'
        QtMocHelpers::SlotData<QVector<int>(const int)>(87, 2, QMC::AccessPublic, 0x80000000 | 6, {{
            { QMetaType::Int, 71 },
        }}),
        // Slot 'rama'
        QtMocHelpers::SlotData<QVector<int>(const int)>(88, 2, QMC::AccessPublic, 0x80000000 | 6, {{
            { QMetaType::Int, 71 },
        }}),
        // Slot 'hinduLunarStation'
        QtMocHelpers::SlotData<int(const int)>(89, 2, QMC::AccessPublic, QMetaType::Int, {{
            { QMetaType::Int, 31 },
        }}),
        // Slot 'karana'
        QtMocHelpers::SlotData<int(const int)>(90, 2, QMC::AccessPublic, QMetaType::Int, {{
            { QMetaType::Int, 91 },
        }}),
        // Slot 'karanaForDay'
        QtMocHelpers::SlotData<int(const int)>(92, 2, QMC::AccessPublic, QMetaType::Int, {{
            { QMetaType::Int, 31 },
        }}),
        // Slot 'yoga'
        QtMocHelpers::SlotData<int(const int)>(93, 2, QMC::AccessPublic, QMetaType::Int, {{
            { QMetaType::Int, 31 },
        }}),
        // Slot 'sacredWednesdays'
        QtMocHelpers::SlotData<QVector<int>(const int)>(94, 2, QMC::AccessPublic, 0x80000000 | 6, {{
            { QMetaType::Int, 71 },
        }}),
        // Slot 'sacredWednesdaysInRange'
        QtMocHelpers::SlotData<QVector<int>(const QVector<int> &)>(95, 2, QMC::AccessPublic, 0x80000000 | 6, {{
            { 0x80000000 | 6, 96 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<NewHinduCalendar, qt_meta_tag_ZN16NewHinduCalendarE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject NewHinduCalendar::staticMetaObject = { {
    QMetaObject::SuperData::link<OldHinduLuniSolarCalendar::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16NewHinduCalendarE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16NewHinduCalendarE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN16NewHinduCalendarE_t>.metaTypes,
    nullptr
} };

void NewHinduCalendar::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<NewHinduCalendar *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->retranslate(); break;
        case 1: _t->setJD((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 2: _t->setDate((*reinterpret_cast<std::add_pointer_t<QList<int>>>(_a[1]))); break;
        case 3: { QStringList _r = _t->getDateStrings();
            if (_a[0]) *reinterpret_cast<QStringList*>(_a[0]) = std::move(_r); }  break;
        case 4: { QString _r = _t->getFormattedDateString();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 5: { double _r = _t->hinduSineTable((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 6: { double _r = _t->hinduSine((*reinterpret_cast<std::add_pointer_t<double>>(_a[1])));
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 7: { double _r = _t->hinduArcsin((*reinterpret_cast<std::add_pointer_t<double>>(_a[1])));
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 8: { double _r = _t->hinduMeanPosition((*reinterpret_cast<std::add_pointer_t<double>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[2])));
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 9: { double _r = _t->hinduTruePosition((*reinterpret_cast<std::add_pointer_t<double>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[5])));
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 10: { double _r = _t->hinduSolarLongitude((*reinterpret_cast<std::add_pointer_t<double>>(_a[1])));
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 11: { int _r = _t->hinduZodiac((*reinterpret_cast<std::add_pointer_t<double>>(_a[1])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 12: { double _r = _t->hinduLunarLongitude((*reinterpret_cast<std::add_pointer_t<double>>(_a[1])));
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 13: { double _r = _t->hinduLunarPhase((*reinterpret_cast<std::add_pointer_t<double>>(_a[1])));
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 14: { int _r = _t->hinduLunarDayFromMoment((*reinterpret_cast<std::add_pointer_t<double>>(_a[1])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 15: { double _r = _t->hinduNewMoonBefore((*reinterpret_cast<std::add_pointer_t<double>>(_a[1])));
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 16: { int _r = _t->hinduCalendarYear((*reinterpret_cast<std::add_pointer_t<double>>(_a[1])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 17: { QList<int> _r = _t->hinduSolarFromFixed((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QList<int>*>(_a[0]) = std::move(_r); }  break;
        case 18: { int _r = _t->fixedFromHinduSolar((*reinterpret_cast<std::add_pointer_t<QList<int>>>(_a[1])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 19: { QList<int> _r = _t->hinduLunarFromFixed((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QList<int>*>(_a[0]) = std::move(_r); }  break;
        case 20: { int _r = _t->fixedFromHinduLunar((*reinterpret_cast<std::add_pointer_t<QList<int>>>(_a[1])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 21: { double _r = _t->hinduAscensionalDifference((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<StelLocation>>(_a[2])));
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 22: { double _r = _t->hinduAscensionalDifference((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 23: { double _r = _t->hinduAscensionalDifference((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 24: { double _r = _t->hinduTropicalLongitude((*reinterpret_cast<std::add_pointer_t<double>>(_a[1])));
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 25: { double _r = _t->hinduSolarSiderealDifference((*reinterpret_cast<std::add_pointer_t<double>>(_a[1])));
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 26: { double _r = _t->hinduDailyMotion((*reinterpret_cast<std::add_pointer_t<double>>(_a[1])));
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 27: { double _r = _t->hinduRisingSign((*reinterpret_cast<std::add_pointer_t<double>>(_a[1])));
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 28: { double _r = _t->hinduEquationOfTime((*reinterpret_cast<std::add_pointer_t<double>>(_a[1])));
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 29: { double _r = _t->hinduSunrise((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 30: { double _r = _t->hinduSunset((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 31: { double _r = _t->hinduStandardFromSundial((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 32: { QList<int> _r = _t->hinduFullMoonFromFixed((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QList<int>*>(_a[0]) = std::move(_r); }  break;
        case 33: { int _r = _t->fixedFromHinduFullMoon((*reinterpret_cast<std::add_pointer_t<QList<int>>>(_a[1])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 34: { bool _r = _t->hinduExpunged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 35: { double _r = _t->altHinduSunrise((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 36: { double _r = _t->siderealSolarLongitude((*reinterpret_cast<std::add_pointer_t<double>>(_a[1])));
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 37: { double _r = _t->ayanamsha((*reinterpret_cast<std::add_pointer_t<double>>(_a[1])));
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 38: { double _r = _t->siderealStart();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 39: { double _r = _t->astroHinduSunset((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 40: { int _r = _t->siderealZodiac((*reinterpret_cast<std::add_pointer_t<double>>(_a[1])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 41: { int _r = _t->astroHinduCalendarYear((*reinterpret_cast<std::add_pointer_t<double>>(_a[1])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 42: { QList<int> _r = _t->astroHinduSolarFromFixed((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QList<int>*>(_a[0]) = std::move(_r); }  break;
        case 43: { int _r = _t->fixedFromAstroHinduSolar((*reinterpret_cast<std::add_pointer_t<QList<int>>>(_a[1])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 44: { int _r = _t->astroLunarDayFromMoment((*reinterpret_cast<std::add_pointer_t<double>>(_a[1])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 45: { QList<int> _r = _t->astroHinduLunarFromFixed((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QList<int>*>(_a[0]) = std::move(_r); }  break;
        case 46: { int _r = _t->fixedFromAstroHinduLunar((*reinterpret_cast<std::add_pointer_t<QList<int>>>(_a[1])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 47: { double _r = _t->hinduSolarLongitudeInv((*reinterpret_cast<std::add_pointer_t<double>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[3])));
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 48: { double _r = _t->hinduSolarLongitudeAtOrAfter((*reinterpret_cast<std::add_pointer_t<double>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[2])));
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 49: { double _r = _t->meshaSamkranti((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 50: { double _r = _t->hinduLunarPhaseInv((*reinterpret_cast<std::add_pointer_t<double>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[3])));
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 51: { double _r = _t->hinduLunarDayAtOrAfter((*reinterpret_cast<std::add_pointer_t<double>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[2])));
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 52: { double _r = _t->hinduLunarNewYear((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 53: { bool _r = _t->hinduLunarOnOrBefore((*reinterpret_cast<std::add_pointer_t<QList<int>>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QList<int>>>(_a[2])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 54: { int _r = _t->hinduDateOccur((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 55: { QList<int> _r = _t->hinduLunarHoliday((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])));
            if (_a[0]) *reinterpret_cast<QList<int>*>(_a[0]) = std::move(_r); }  break;
        case 56: { QList<int> _r = _t->diwali((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QList<int>*>(_a[0]) = std::move(_r); }  break;
        case 57: { int _r = _t->hinduTithiOccur((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[4])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 58: { QList<int> _r = _t->hinduLunarEvent((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[4])));
            if (_a[0]) *reinterpret_cast<QList<int>*>(_a[0]) = std::move(_r); }  break;
        case 59: { QList<int> _r = _t->shiva((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QList<int>*>(_a[0]) = std::move(_r); }  break;
        case 60: { QList<int> _r = _t->rama((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QList<int>*>(_a[0]) = std::move(_r); }  break;
        case 61: { int _r = _t->hinduLunarStation((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 62: { int _r = _t->karana((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 63: { int _r = _t->karanaForDay((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 64: { int _r = _t->yoga((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 65: { QList<int> _r = _t->sacredWednesdays((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QList<int>*>(_a[0]) = std::move(_r); }  break;
        case 66: { QList<int> _r = _t->sacredWednesdaysInRange((*reinterpret_cast<std::add_pointer_t<QList<int>>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QList<int>*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 2:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QList<int> >(); break;
            }
            break;
        case 18:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QList<int> >(); break;
            }
            break;
        case 20:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QList<int> >(); break;
            }
            break;
        case 21:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< StelLocation >(); break;
            }
            break;
        case 33:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QList<int> >(); break;
            }
            break;
        case 43:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QList<int> >(); break;
            }
            break;
        case 46:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QList<int> >(); break;
            }
            break;
        case 53:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QList<int> >(); break;
            }
            break;
        case 66:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QList<int> >(); break;
            }
            break;
        }
    }
}

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

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

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